Shared dependencies in FastAPI - Step-by-Step Execution

Concept Flow - Shared dependencies

Define dependency function

↓

Declare dependency in endpoint

↓

FastAPI calls dependency

↓

Dependency returns value

↓

Endpoint uses returned value

↓

Response sent to client

FastAPI calls shared dependency functions before endpoints, passing their results to endpoints for reuse.

Execution Sample

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def common_dep():
    return "shared value"

@app.get("/items")
async def read_items(value: str = Depends(common_dep)):
    return {"value": value}

This code defines a shared dependency function and uses it in an endpoint to provide a value.

Execution Table

Step	Action	Dependency Called	Dependency Result	Endpoint Parameter	Response
1	Request to /items received	No	N/A	N/A	N/A
2	FastAPI calls common_dep()	Yes	"shared value"	N/A	N/A
3	common_dep() returns	Yes	"shared value"	N/A	N/A
4	Endpoint read_items called with value="shared value"	No	N/A	"shared value"	N/A
5	Endpoint returns response	No	N/A	N/A	{"value": "shared value"}

💡 Request handled after dependency provides value and endpoint returns response

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
value	N/A	"shared value"	"shared value"	"shared value"

Key Moments - 3 Insights

Why does FastAPI call the dependency function before the endpoint?

FastAPI calls the dependency first to get the value it needs to pass into the endpoint parameter, as shown in execution_table step 2 and 4.

Can the same dependency be used in multiple endpoints?

Yes, shared dependencies can be reused across endpoints to avoid repeating code, as the dependency function is independent and called each time.

What happens if the dependency returns a different value each time?

The endpoint receives the new value each time because FastAPI calls the dependency fresh on every request, shown by the dependency call in step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'value' when the endpoint read_items is called?

A None

B N/A

C "shared value"

D "common_dep"

💡 Hint

Check the 'Endpoint Parameter' column at step 4 in the execution_table.

At which step does FastAPI call the dependency function?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Dependency Called' column in the execution_table.

If the dependency returned "new value" instead, what would change in the execution_table?

A Dependency Result and Endpoint Parameter would show "new value"

B Response would be unchanged

C Dependency Called would be No

D Endpoint would not be called

💡 Hint

Focus on the 'Dependency Result' and 'Endpoint Parameter' columns in the execution_table.

Concept Snapshot

FastAPI Shared Dependencies:
- Define a function to provide shared data
- Use Depends() in endpoint parameters
- FastAPI calls dependency before endpoint
- Dependency return value passed to endpoint
- Enables code reuse and cleaner endpoints

Full Transcript

In FastAPI, shared dependencies are functions that provide values or logic reused by multiple endpoints. When a request comes in, FastAPI first calls the dependency function to get its result. Then it passes this result as an argument to the endpoint function. This way, the endpoint can use shared data or logic without repeating code. The execution table shows the request flow: receiving the request, calling the dependency, returning its value, calling the endpoint with that value, and finally sending the response. Variables like 'value' hold the dependency's output and are tracked through the steps. Understanding this flow helps beginners see how FastAPI manages dependencies behind the scenes.

Practice

1. What is the main purpose of using Depends() in FastAPI for shared dependencies?

easy

A. To reuse code across multiple routes by declaring common dependencies

B. To create a new route in the application

C. To handle database connections manually

D. To define the response model for an endpoint

Solution

1. Step 1: Understand the role of Depends()

   Depends() is used in FastAPI to declare dependencies that can be shared across multiple routes.

2. Step 2: Identify the main benefit

   Using shared dependencies helps reuse code and keep the app clean and maintainable.

3. Final Answer:

   To reuse code across multiple routes by declaring common dependencies -> Option A

4. Quick Check:

   Shared dependencies = reuse code [OK]

Hint: Depends() means shared code for many routes [OK]

Common Mistakes:

• Thinking Depends() creates routes
• Confusing Depends() with response models
• Assuming Depends() manages database connections directly

2. Which of the following is the correct way to declare a shared dependency in a FastAPI route?

easy

A. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass

B. def get_db(): return Session(); @app.get('/items') def read_items(db=get_db()): pass

C. def get_db(): return Session(); @app.get('/items') def read_items(db: Session): pass

D. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends()): pass

Solution

1. Step 1: Review correct dependency syntax

   In FastAPI, dependencies are declared using Depends(function_name) inside the function parameters.

2. Step 2: Check each option

   def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass correctly uses db=Depends(get_db). def get_db(): return Session(); @app.get('/items') def read_items(db=get_db()): pass calls the function directly, which is incorrect. def get_db(): return Session(); @app.get('/items') def read_items(db: Session): pass lacks Depends, so no injection happens. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends()): pass uses Depends without a function, which is invalid.

3. Final Answer:

   def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass -> Option A

4. Quick Check:

   Depends() needs function inside [OK]

Hint: Depends() must wrap the dependency function [OK]

Common Mistakes:

• Calling dependency function directly in parameter
• Forgetting to use Depends() wrapper
• Using Depends() without specifying the function

3. Given the code below, what will be the output when accessing /items/42?

from fastapi import FastAPI, Depends

app = FastAPI()

def common_dep():
    return "shared value"

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

medium

A. Error: Missing required parameter 'value'

B. {"item_id": 42, "value": 42}

C. {"item_id": 42, "value": null}

D. {"item_id": 42, "value": "shared value"}

Solution

1. Step 1: Understand dependency injection

   The function common_dep returns the string "shared value". FastAPI injects this into the value parameter via Depends(common_dep).

2. Step 2: Check the returned JSON

   The route returns a dictionary with item_id from the path and value from the dependency. So the output will be {"item_id": 42, "value": "shared value"}.

3. Final Answer:

   {"item_id": 42, "value": "shared value"} -> Option D

4. Quick Check:

   Dependency injects "shared value" [OK]

Hint: Depends injects return value as parameter [OK]

Common Mistakes:

• Assuming dependency returns item_id
• Expecting error due to missing parameter
• Thinking value will be null without explicit call

4. Identify the error in the following FastAPI code using shared dependencies:

from fastapi import FastAPI, Depends

app = FastAPI()

def get_token():
    return "token123"

@app.get('/secure')
def secure_route(token: str = Depends()):
    return {"token": token}

medium

A. The function secure_route should not have parameters

B. The dependency function get_token() should return an int

C. Depends() is missing the dependency function inside

D. The route decorator is missing parentheses

Solution

1. Step 1: Check Depends usage

   The parameter token uses Depends() without specifying the dependency function. This is incorrect syntax.

2. Step 2: Correct usage

   Depends must wrap the function providing the dependency, so it should be Depends(get_token).

3. Final Answer:

   Depends() is missing the dependency function inside -> Option C

4. Quick Check:

   Depends() needs function argument [OK]

Hint: Depends() always needs a function inside [OK]

Common Mistakes:

• Using Depends() without argument
• Expecting Depends() to work without function
• Confusing Depends() with decorator syntax

5. You want to share a database session dependency across multiple routes but also ensure it closes after each request. Which approach correctly uses shared dependencies with cleanup in FastAPI?

hard

A. Create the session globally once and reuse it without closing

B. Use a dependency function with yield that creates the session, yields it, then closes it after

C. Pass the session as a normal parameter without Depends()

D. Use Depends() but close the session manually inside each route

Solution

1. Step 1: Understand dependency cleanup

   FastAPI supports dependencies with cleanup by using yield inside the dependency function. This allows setup before yield and cleanup after.

2. Step 2: Apply to database session

   The correct pattern is to create the session, yield it for use in routes, then close it after the request finishes.

3. Final Answer:

   Use a dependency function with yield that creates the session, yields it, then closes it after -> Option B

4. Quick Check:

   Yield in dependency = setup and cleanup [OK]

Hint: Use yield in dependency for setup and cleanup [OK]

Common Mistakes:

• Reusing global session without closing
• Closing session inside route instead of dependency
• Not using Depends() for session injection