Dependencies with parameters in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a dependency with parameters in FastAPI?

A dependency with parameters is a function that accepts arguments and returns a value to be injected into path operations or other dependencies. It allows customizing behavior based on input values.

intermediate

How do you declare a dependency with parameters in FastAPI?

You create a function that takes parameters and returns a callable dependency function. Then you use Depends with a lambda or functools.partial to pass parameters when injecting.

beginner

Why use dependencies with parameters instead of global dependencies?

Dependencies with parameters let you customize the dependency's behavior per request or route, making your code more flexible and reusable.

intermediate

Example: How to pass a parameter to a dependency in FastAPI?

Define a function that returns another function using the parameter. Use Depends with a lambda: e.g., Depends(lambda: get_db(session_id=123)).

beginner

What happens if you forget to pass parameters to a dependency that requires them?

FastAPI will raise an error because it cannot resolve the dependency properly. Parameters must be provided explicitly or via another dependency.

How do you inject a dependency with a parameter in FastAPI?

A Use Depends with a lambda or partial function to pass parameters

B Declare parameters directly in the path operation function

C Use global variables inside the dependency function

D FastAPI does not support dependencies with parameters

You pass parameters by wrapping the dependency call in a lambda or partial function inside Depends.

What is the purpose of dependencies with parameters?

A To define global constants

B To make dependencies run faster

C To avoid using Depends in FastAPI

D To customize dependency behavior per request or route

Dependencies with parameters allow you to change how the dependency works depending on input values.

Which of these is a correct way to define a dependency with parameters?

A def get_user(user_id: int): return user_id

B def get_user(user_id: int): def dependency(): return user_id; return dependency

C def get_user(): return user_id

D def get_user(): pass

You define a function that returns another function capturing the parameter.

What happens if a dependency with parameters is used without passing required parameters?

A FastAPI raises an error at runtime

B The dependency uses default parameters automatically

C The dependency is ignored

D The server crashes immediately

FastAPI cannot resolve the dependency and raises an error if parameters are missing.

Which FastAPI feature helps pass parameters to dependencies?

A Middleware

B Path parameters only

C Depends with lambda or functools.partial

D Background tasks

Depends combined with lambda or partial lets you pass parameters to dependencies.

Explain how to create and use a dependency with parameters in FastAPI.

Think about wrapping the dependency function to capture parameters.

Why are dependencies with parameters useful in FastAPI applications?

Consider how parameters help change dependency output.

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