Sub-dependencies in FastAPI

Introduction

Sub-dependencies help you organize and reuse small parts of your code that other parts depend on. They make your code cleaner and easier to manage.

When you have a common piece of logic needed by multiple dependencies.

When you want to break down complex dependencies into smaller, simpler parts.

When you want to share authentication or database connection logic across different routes.

When you want to keep your code DRY (Don't Repeat Yourself) by reusing dependency functions.

Syntax

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def sub_dependency():
    return "sub value"

def main_dependency(sub_val: str = Depends(sub_dependency)):
    return f"main uses {sub_val}"

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

Use Depends() inside another dependency function to create sub-dependencies.

FastAPI will resolve sub-dependencies automatically when you call the main dependency.

Examples

This example shows a sub-dependency get_token used inside verify_token to check a token.

FastAPI

from fastapi import Depends, HTTPException

def get_token():
    return "token123"

def verify_token(token: str = Depends(get_token)):
    if token != "token123":
        raise HTTPException(status_code=401)
    return True

Here, get_db is a sub-dependency that provides a database connection to get_user.

FastAPI

from fastapi import Depends

def get_db():
    db = "database connection"
    try:
        yield db
    finally:
        print("close db")

def get_user(db = Depends(get_db)):
    return f"user from {db}"

Sample Program

This program uses sub-dependencies to check a token before giving access to protected data. get_token provides the token, verify_token checks it, and get_data returns data if the token is valid.

FastAPI

from fastapi import FastAPI, Depends, HTTPException

app = FastAPI()

def get_token():
    return "secret-token"

def verify_token(token: str = Depends(get_token)):
    if token != "secret-token":
        raise HTTPException(status_code=401, detail="Invalid token")
    return token

def get_data(token: str = Depends(verify_token)):
    return {"data": "Here is your protected data."}

@app.get("/protected")
async def protected_route(data = Depends(get_data)):
    return data

Important Notes

Sub-dependencies help keep your code modular and easier to test.

FastAPI resolves sub-dependencies automatically in the right order.

Use sub-dependencies to share common logic like authentication or database access.

Summary

Sub-dependencies let you reuse small parts of code inside other dependencies.

They make your code cleaner and easier to maintain.

FastAPI handles sub-dependencies automatically for you.

Practice

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

easy

A. To handle HTTP requests directly

B. To create database connections only

C. To reuse small parts of code inside other dependencies

D. To replace middleware functions

Solution

1. Step 1: Understand what sub-dependencies do

   Sub-dependencies allow you to reuse small parts of code inside other dependencies, making your code cleaner.

2. Step 2: Compare options with this purpose

   Only To reuse small parts of code inside other dependencies correctly describes this purpose; others describe unrelated tasks.

3. Final Answer:

   To reuse small parts of code inside other dependencies -> Option C

4. Quick Check:

   Sub-dependencies = Reuse code [OK]

Hint: Sub-dependencies help reuse code inside dependencies [OK]

Common Mistakes:

• Thinking sub-dependencies handle HTTP requests directly
• Confusing sub-dependencies with middleware
• Assuming sub-dependencies only manage database connections

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

easy

A. def sub_dep(): return 'data'

def main_dep(sub: str = Depends(sub_dep)): return sub

B. def sub_dep(): return 'data'

def main_dep(sub: str = sub_dep()): return sub

C. def sub_dep(): return 'data'

def main_dep(sub: str = Depends(sub_dep())): return sub

D. def sub_dep(): return 'data'

def main_dep(sub: str): return sub

Solution

1. Step 1: Recall FastAPI dependency syntax

   Dependencies must be passed as functions inside Depends(), not called directly.

2. Step 2: Analyze each option

   def sub_dep(): return 'data' def main_dep(sub: str = Depends(sub_dep)): return sub correctly uses Depends(sub_dep) without calling it. Options B and C call the function, which is incorrect. def sub_dep(): return 'data' def main_dep(sub: str): return sub lacks Depends entirely.

3. Final Answer:

   def sub_dep(): return 'data'\n\ndef main_dep(sub: str = Depends(sub_dep)): return sub -> Option A

4. Quick Check:

   Use Depends(function) without parentheses [OK]

Hint: Use Depends with function name, no parentheses [OK]

Common Mistakes:

• Calling the dependency function inside Depends()
• Not using Depends at all
• Passing the function call result instead of the function

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

from fastapi import FastAPI, Depends

app = FastAPI()

def sub_dep():
    return "sub-data"

def main_dep(data: str = Depends(sub_dep)):
    return f"main uses {data}"

@app.get("/items/{item_id}")
async def read_item(item_id: int, info: str = Depends(main_dep)):
    return {"item_id": item_id, "info": info}

medium

A. {"item_id": 42, "info": "main_dep"}

B. {"item_id": 42, "info": "main uses sub-data"}

C. {"item_id": 42, "info": "sub-data"}

D. Runtime error due to missing parameters

Solution

1. Step 1: Understand dependency chaining

   The read_item endpoint depends on main_dep, which depends on sub_dep. The value from sub_dep is passed to main_dep.

2. Step 2: Trace returned values

   sub_dep() returns "sub-data". main_dep returns "main uses sub-data". So info in read_item is "main uses sub-data".

3. Final Answer:

   {"item_id": 42, "info": "main uses sub-data"} -> Option B

4. Quick Check:

   Sub-dependencies chain output correctly [OK]

Hint: Follow dependency chain outputs step-by-step [OK]

Common Mistakes:

• Ignoring sub-dependency output in main dependency
• Assuming direct sub_dep output is returned
• Expecting runtime errors without cause

4. What is the error in the following FastAPI code using sub-dependencies?

from fastapi import FastAPI, Depends

app = FastAPI()

def sub_dep():
    return "data"

def main_dep(data: str = Depends(sub_dep)):
    return data

@app.get("/test")
async def test_endpoint(info: str = Depends(main_dep())):
    return {"info": info}

medium

A. Calling main_dep() inside Depends instead of passing the function

B. Missing return statement in sub_dep

C. Incorrect route path syntax

D. Using async def for endpoint without await

Solution

1. Step 1: Identify how Depends should be used

   Depends expects a function reference, not a function call. Calling main_dep() executes it immediately, which is wrong.

2. Step 2: Check the code for this mistake

   The code uses Depends(main_dep()), which calls the function instead of passing it. It should be Depends(main_dep).

3. Final Answer:

   Calling main_dep() inside Depends instead of passing the function -> Option A

4. Quick Check:

   Depends needs function, not function call [OK]

Hint: Pass function to Depends, don't call it [OK]

Common Mistakes:

• Calling dependency functions inside Depends()
• Confusing async usage with dependency errors
• Ignoring Depends syntax rules

5. You want to create a FastAPI endpoint that depends on a main dependency which itself depends on two sub-dependencies. How should you structure the dependencies to ensure both sub-dependencies are called and their results used in the main dependency?

hard

A. Call both sub-dependencies inside main dependency without Depends()

B. Pass sub-dependencies as global variables to main dependency

C. Use a single sub-dependency that returns a tuple of both results

D. Define two sub-dependency functions, then in main dependency use Depends() for both as parameters

Solution

1. Step 1: Understand sub-dependency usage in main dependency

   FastAPI allows multiple dependencies by declaring parameters with Depends(). To use two sub-dependencies, declare both as parameters with Depends().

2. Step 2: Evaluate options for correctness

   Define two sub-dependency functions, then in main dependency use Depends() for both as parameters correctly describes this pattern. Call both sub-dependencies inside main dependency without Depends() misses Depends(), so sub-dependencies won't be injected. Use a single sub-dependency that returns a tuple of both results is possible but less clear and not standard. Pass sub-dependencies as global variables to main dependency is incorrect as global variables don't work for dependency injection.

3. Final Answer:

   Define two sub-dependency functions, then in main dependency use Depends() for both as parameters -> Option D

4. Quick Check:

   Multiple Depends parameters call multiple sub-dependencies [OK]

Hint: Use multiple Depends() parameters in main dependency [OK]

Common Mistakes:

• Calling sub-dependencies directly without Depends
• Trying to pass sub-dependencies as globals
• Combining sub-dependencies into one without clear structure