Why Sub-dependencies in FastAPI? - Purpose & Use Cases

The Big Idea

Discover how sub-dependencies can save you from tangled, repetitive code in FastAPI!

The Scenario

Imagine building a web app where multiple parts need user info, database access, and logging. You write code to get these for each part separately.

The Problem

Manually passing user info, database connections, and logs everywhere is tiring and easy to mess up. It leads to repeated code and bugs when you forget to pass something.

The Solution

FastAPI's sub-dependencies let you define small reusable pieces that automatically provide needed data or services. They connect smoothly, so each part gets exactly what it needs without extra work.

Before vs After

✗ Before

def endpoint(user=Depends(get_user), db=Depends(get_db), logger=Depends(get_logger)):
    # repeated calls and passing
    pass

✓ After

def common_deps(user=Depends(get_user), db=Depends(get_db), logger=Depends(get_logger)):
    return user, db, logger

def endpoint(deps=Depends(common_deps)):
    user, db, logger = deps
    pass

What It Enables

This makes your code cleaner, easier to maintain, and lets you build complex dependency chains effortlessly.

Real Life Example

In a social media app, many routes need the current user and database. Using sub-dependencies, you write this once and reuse it everywhere, saving time and avoiding mistakes.

Key Takeaways

Manual passing of shared resources is repetitive and error-prone.

Sub-dependencies let you bundle and reuse common dependencies easily.

This leads to cleaner, more maintainable FastAPI code.

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