Global dependencies in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a global dependency in FastAPI?

A global dependency is a function or class that FastAPI runs for every request in an application or router, providing shared logic like authentication or database sessions.

beginner

How do you declare a global dependency in FastAPI?

You declare a global dependency by passing it to the 'dependencies' parameter of the FastAPI app or APIRouter, so it runs automatically for all routes inside.

intermediate

What is a practical example of a global dependency?

A common example is an authentication check that runs before every request to verify the user is logged in, so you don't repeat this check in every route.

intermediate

Can global dependencies return values to route functions in FastAPI?

Yes, global dependencies can return values that route functions receive as parameters, allowing shared data like user info or database sessions to be used inside routes.

intermediate

What happens if a global dependency raises an exception in FastAPI?

If a global dependency raises an exception, FastAPI stops processing the request and returns an error response, preventing the route handler from running.

How do you apply a global dependency to all routes in a FastAPI app?

A Pass the dependency to the 'dependencies' parameter when creating the FastAPI app

B Add the dependency inside each route function manually

C Use a middleware instead of dependencies

D Call the dependency inside the main function

Global dependencies are set by passing them to the 'dependencies' parameter of the FastAPI app or router, so they run automatically for all routes.

What is a benefit of using global dependencies in FastAPI?

A They make the app slower by adding extra steps

B They reduce repeated code by sharing logic across routes

C They replace the need for route functions

D They automatically generate HTML pages

Global dependencies help avoid repeating the same code in every route by running shared logic once for all routes.

Can global dependencies in FastAPI provide data to route handlers?

A Yes, they can return values that routes receive as parameters

B No, they only run code but cannot pass data

C Only if you use global variables

D Only if you use middleware

Global dependencies can return values that FastAPI injects into route function parameters for use inside the route.

Where else besides the FastAPI app can you set global dependencies?

A In the HTML templates

B Only in the main app

C In the database connection

D In APIRouter instances

You can set global dependencies on APIRouter objects to apply them to all routes within that router.

What happens if a global dependency raises an HTTPException?

A The exception is ignored

B The request continues normally

C FastAPI returns the error response immediately

D The server crashes

If a global dependency raises an HTTPException, FastAPI stops processing and returns the error response to the client.

Explain how to use global dependencies in FastAPI and why they are useful.

Think about code you want to run for every request without repeating it.

Describe what happens when a global dependency raises an error in FastAPI.

Consider how FastAPI handles exceptions in dependencies.

Practice

1. What is the main purpose of global dependencies in FastAPI?

easy

A. To create database models

B. To define route-specific logic only

C. To style the API responses

D. To run shared logic automatically for every request

Solution

1. Step 1: Understand what global dependencies do

   Global dependencies are functions or classes that run for every request to apply shared logic.

2. Step 2: Identify their main use

   They help with tasks like authentication, database connections, or validations that apply to all routes.

3. Final Answer:

   To run shared logic automatically for every request -> Option D

4. Quick Check:

   Global dependencies = shared logic for all requests [OK]

Hint: Global dependencies run once per request for all routes [OK]

Common Mistakes:

• Thinking global dependencies are for styling
• Confusing global with route-specific dependencies
• Assuming they create database models

2. Which of the following is the correct way to add a global dependency in FastAPI?

easy

A. app = FastAPI(dependencies=[Depends(common_dependency)])

B. app = FastAPI(global_dep=Depends(common_dependency))

C. app = FastAPI(dependency=common_dependency())

D. app = FastAPI(use_global=common_dependency)

Solution

1. Step 1: Recall FastAPI global dependency syntax

   Global dependencies are passed as a list to the 'dependencies' parameter when creating the FastAPI app.

2. Step 2: Match the correct syntax

   app = FastAPI(dependencies=[Depends(common_dependency)]) uses 'dependencies=[Depends(common_dependency)]', which is the correct pattern.

3. Final Answer:

   app = FastAPI(dependencies=[Depends(common_dependency)]) -> Option A

4. Quick Check:

   Global dependencies use dependencies=[Depends(...)] [OK]

Hint: Use dependencies=[Depends(...)] in FastAPI() constructor [OK]

Common Mistakes:

• Using wrong parameter names like global_dep or use_global
• Calling the dependency function instead of passing Depends()
• Passing a single dependency without a list

3. Given this code snippet, what will be printed when a request is made to /items/42?

from fastapi import FastAPI, Depends

app = FastAPI()

def common_dep():
    print("Global dependency called")

@app.get("/items/{item_id}")
def read_item(item_id: int, dep=Depends(common_dep)):
    return {"item_id": item_id}

medium

A. No output printed because common_dep is not global

B. Global dependency called printed once per request

C. Global dependency called printed twice per request

D. SyntaxError due to missing global dependency

Solution

1. Step 1: Check how common_dep is used

   common_dep is used as a route dependency only on the read_item function, not as a global dependency.

2. Step 2: Understand when common_dep runs

   It runs only when the /items/{item_id} route is called, printing the message once per request to that route.

3. Final Answer:

   Global dependency called printed once per request -> Option B

4. Quick Check:

   Route dependency prints only when route is called, not global [OK]

Hint: Route dependencies run per route, not global unless set globally [OK]

Common Mistakes:

• Assuming common_dep is global when it's route-specific
• Expecting multiple prints per request
• Confusing global and route dependencies

4. Identify the error in this FastAPI app code that tries to use a global dependency:

from fastapi import FastAPI, Depends

def common_dep():
    print("Running global dependency")

app = FastAPI(dependencies=Depends(common_dep))

medium

A. common_dep is not defined before use

B. Missing parentheses when calling FastAPI()

C. dependencies parameter expects a list, not a single Depends

D. Depends cannot be used as a global dependency

Solution

1. Step 1: Check the dependencies parameter type

   The 'dependencies' argument expects a list of Depends instances, not a single Depends object.

2. Step 2: Identify the fix

   Wrap Depends(common_dep) inside a list: dependencies=[Depends(common_dep)]

3. Final Answer:

   dependencies parameter expects a list, not a single Depends -> Option C

4. Quick Check:

   dependencies=[Depends(...)] requires a list [OK]

Hint: Always pass dependencies as a list, even if one item [OK]

Common Mistakes:

• Passing Depends(...) directly without list
• Defining dependency after app creation
• Confusing Depends usage with function call

5. You want to add a global dependency that checks user authentication and also logs request info. Which is the best way to combine these in FastAPI?

hard

A. Add both auth check and logging as separate global dependencies in the dependencies list

B. Add auth check as global dependency and logging inside each route

C. Create one dependency function that calls both auth check and logging, then add it globally

D. Use middleware for auth and global dependency for logging

Solution

1. Step 1: Understand global dependencies list

   FastAPI allows multiple global dependencies by passing a list to the dependencies parameter.

2. Step 2: Combine auth and logging as separate dependencies

   Adding both as separate Depends in the list keeps concerns separated and runs both for every request.

3. Step 3: Evaluate other options

   Create one dependency function that calls both auth check and logging, then add it globally mixes concerns in one function, B is inconsistent, D mixes middleware and dependencies unnecessarily.

4. Final Answer:

   Add both auth check and logging as separate global dependencies in the dependencies list -> Option A

5. Quick Check:

   Multiple global dependencies = dependencies=[Depends(...), Depends(...)] [OK]

Hint: Use a list of Depends for multiple global dependencies [OK]

Common Mistakes:

• Combining unrelated logic in one dependency
• Using middleware instead of dependencies for all tasks
• Adding some logic only per route, not globally