Dependencies with parameters in FastAPI - Step-by-Step Execution

Concept Flow - Dependencies with parameters

Define dependency function with parameter

↓

Use Depends() in path operation with argument

↓

FastAPI calls dependency with parameter

↓

Dependency returns value

↓

Path operation receives dependency result

↓

Return response using dependency result

This flow shows how FastAPI calls a dependency function with parameters and passes its result to the path operation.

Execution Sample

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def query_extractor(q: str):
    return q

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

This code defines a dependency function that takes a parameter and uses it in a path operation.

Execution Table

Step	Action	Parameter q	Dependency Return	Path Operation Input	Response
1	Request to /items/?q=hello	hello	hello	hello	{"q": "hello"}
2	Request to /items/ without q	missing	Error (422)	N/A	Error response (422 Unprocessable Entity)
3	Request to /items/?q=fastapi	fastapi	fastapi	fastapi	{"q": "fastapi"}

💡 Execution stops after returning response or error for each request.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3
q	N/A	hello	missing (error)	fastapi
Dependency Return	N/A	hello	Error (no return)	fastapi
Path Operation Input	N/A	hello	N/A	fastapi

Key Moments - 2 Insights

Why does the request without 'q' cause an error?

Because the dependency function requires 'q' as a parameter, and FastAPI cannot provide it if missing, causing a validation error as shown in step 2 of the execution_table.

How does FastAPI pass the query parameter to the dependency?

FastAPI extracts the query parameter 'q' from the request URL and passes it to the dependency function as shown in the 'Parameter q' column in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'q' passed to the dependency in step 3?

A "fastapi"

B "hello"

C missing

D None

💡 Hint

Check the 'Parameter q' column in step 3 of the execution_table.

At which step does the dependency cause an error due to missing parameter?

A Step 3

B Step 1

C Step 2

D No error occurs

💡 Hint

Look at the 'Dependency Return' and 'Response' columns in the execution_table.

If the dependency function had a default value for 'q', how would step 2 change?

A The path operation would not run

B It would return the default value instead of error

C It would still cause an error

D The server would crash

💡 Hint

Think about how default parameters affect function calls in Python and FastAPI.

Concept Snapshot

FastAPI dependencies can accept parameters.
Define a function with parameters.
Use Depends() in path operation with that function.
FastAPI injects parameters from request.
Dependency returns value used in path operation.
Missing parameters cause validation errors.

Full Transcript

This example shows how FastAPI handles dependencies with parameters. A dependency function named query_extractor takes a parameter 'q'. The path operation read_items uses Depends(query_extractor) to get 'q' from the request query parameters. When a request includes 'q', FastAPI passes it to the dependency, which returns it. The path operation then returns it in the response. If 'q' is missing, FastAPI raises a validation error (422). This flow helps reuse logic and access request data cleanly.

Practice

1. What is the main purpose of using dependencies with parameters in FastAPI?

easy

A. To automatically generate HTML templates

B. To create global variables accessible everywhere

C. To replace route functions with classes

D. To customize shared code by passing arguments to dependencies

Solution

1. Step 1: Understand dependency role

   Dependencies in FastAPI are reusable pieces of code that can be shared across routes.

2. Step 2: Recognize parameter use

   Adding parameters to dependencies allows customizing their behavior for different routes or situations.

3. Final Answer:

   To customize shared code by passing arguments to dependencies -> Option D

4. Quick Check:

   Dependencies with parameters = customize shared code [OK]

Hint: Dependencies with parameters customize shared logic easily [OK]

Common Mistakes:

• Thinking dependencies create global variables
• Confusing dependencies with route handlers
• Assuming dependencies generate HTML

2. Which of the following is the correct way to pass a parameter to a dependency in FastAPI?

easy

A. Depends(get_user(user_id=5))

B. Depends(get_user, user_id=5)

C. Depends(get_user)(user_id=5)

D. Depends(get_user)[user_id=5]

Solution

1. Step 1: Recall Depends usage

   Depends expects a callable or a call to a callable that returns a dependency.

2. Step 2: Passing parameters

   To pass parameters, you call the dependency function inside Depends, like Depends(get_user(user_id=5)).

3. Final Answer:

   Depends(get_user(user_id=5)) -> Option A

4. Quick Check:

   Call dependency inside Depends to pass parameters [OK]

Hint: Call dependency inside Depends() to pass parameters [OK]

Common Mistakes:

• Passing parameters directly to Depends without calling
• Using brackets [] instead of parentheses ()
• Trying to call Depends as a function with parameters

3. Given this code snippet, what will be the output when accessing the endpoint?

from fastapi import FastAPI, Depends

app = FastAPI()

def get_multiplier(factor: int):
    def multiplier(value: int):
        return value * factor
    return multiplier

@app.get("/multiply")
async def multiply(value: int, multiply_func = Depends(get_multiplier(3))):
    return {"result": multiply_func(value)}

medium

A. Error because Depends cannot take parameters

B. {"result": 6} when value=3

C. {"result": 9} when value=3

D. {"result": 3} when value=3

Solution

1. Step 1: Understand get_multiplier

   get_multiplier(3) returns a function that multiplies input by 3.

2. Step 2: Analyze endpoint call

   When calling /multiply with value=3, multiply_func(3) returns 3 * 3 = 9.

3. Final Answer:

   {"result": 9} when value=3 -> Option C

4. Quick Check:

   Dependency returns multiplier with factor 3, output 9 [OK]

Hint: Multiply value by factor passed in dependency [OK]

Common Mistakes:

• Assuming Depends cannot take parameters
• Confusing returned function with direct value
• Mixing up multiplication factor

4. Identify the error in this FastAPI dependency usage:

def get_limit(limit: int = 10):
    return limit

@app.get("/items")
async def read_items(limit = Depends(get_limit(limit=20))):
    return {"limit": limit}

medium

A. Default value in get_limit conflicts with parameter passed

B. Cannot pass parameters directly inside Depends like get_limit(limit=20)

C. Missing type annotation for limit in read_items

D. Depends should be imported from fastapi.dependencies

Solution

1. Step 1: Check Depends usage

   Depends expects a callable or a call to a callable without parameters directly inside Depends.

2. Step 2: Correct way to pass parameters

   To pass parameters, wrap get_limit in another function or use a lambda to supply parameters.

3. Final Answer:

   Cannot pass parameters directly inside Depends like get_limit(limit=20) -> Option B

4. Quick Check:

   Depends() must wrap callable, not call with parameters directly [OK]

Hint: Wrap parameterized dependency call outside Depends() [OK]

Common Mistakes:

• Calling dependency with parameters inside Depends directly
• Ignoring need for wrapper function
• Wrong import path for Depends

5. How can you create a reusable dependency with a parameter that changes per route in FastAPI? Choose the best approach.

def common_dep(param: str):
    def dependency():
        return f"Value is {param}"
    return dependency

@app.get("/route1")
async def route1(dep = Depends(common_dep("A"))):
    return {"msg": dep}

@app.get("/route2")
async def route2(dep = Depends(common_dep("B"))):
    return {"msg": dep}

hard

A. Define a function returning a dependency function with parameter, then call it inside Depends

B. Use global variables to store param values for each route

C. Pass parameters directly to Depends without wrapping

D. Create separate dependency functions for each parameter value

Solution

1. Step 1: Understand reusable dependency pattern

   Define a function that returns a dependency function customized by parameters.

2. Step 2: Apply pattern per route

   Call this function with different parameters inside Depends for each route to customize behavior.

3. Final Answer:

   Define a function returning a dependency function with parameter, then call it inside Depends -> Option A

4. Quick Check:

   Wrap dependency with parameter function, call inside Depends [OK]

Hint: Wrap parameterized dependency in function, call inside Depends [OK]

Common Mistakes:

• Using global variables instead of parameters
• Passing parameters directly to Depends without wrapping
• Duplicating dependency functions unnecessarily