Sub-dependencies in FastAPI - Step-by-Step Execution

Concept Flow - Sub-dependencies

Request comes in

↓

Main dependency called

↓

Sub-dependency called

↓

Sub-dependency returns value

↓

Main dependency receives sub-value

↓

Main dependency returns value

↓

Endpoint receives main value

↓

Response sent

The request triggers the main dependency, which calls the sub-dependency. The sub-dependency returns a value used by the main dependency, which then returns its value to the endpoint.

Execution Sample

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def sub_dep():
    return "sub-value"

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

@app.get("/")
async def root(value: str = Depends(main_dep)):
    return {"result": value}

This FastAPI app uses a sub-dependency inside a main dependency, which the endpoint depends on.

Execution Table

Step	Action	Dependency Called	Returned Value	Next Step
1	Request received at '/' endpoint	None	None	Call main_dep()
2	main_dep() starts	sub_dep()	None	Call sub_dep()
3	sub_dep() runs	None	"sub-value"	Return to main_dep()
4	main_dep() receives 'sub-value'	None	"main uses sub-value"	Return to endpoint
5	Endpoint receives 'main uses sub-value'	None	{"result": "main uses sub-value"}	Send response
6	Response sent to client	None	None	End

💡 Response sent, request cycle complete

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
sub_value	None	"sub-value"	"sub-value"	"sub-value"
value	None	None	"main uses sub-value"	"main uses sub-value"

Key Moments - 2 Insights

Why does main_dep call sub_dep before returning?

Because main_dep depends on sub_dep's output to build its own return value, as shown in execution_table step 2 and 3.

What value does the endpoint receive from main_dep?

The endpoint receives the string 'main uses sub-value' returned by main_dep, as seen in execution_table step 5.

Visual Quiz - 3 Questions

Look at the execution table, what value does sub_dep return at step 3?

A "main uses sub-value"

B "sub-value"

C None

D {"result": "main uses sub-value"}

💡 Hint

Check the 'Returned Value' column at step 3 in the execution_table.

At which step does main_dep receive the sub_dep's returned value?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look for when main_dep gets 'sub-value' in the execution_table.

If sub_dep returned 'new-sub-value', what would be the endpoint's final result?

A {"result": "main uses sub-value"}

B {"result": "sub-value"}

C {"result": "main uses new-sub-value"}

D An error occurs

💡 Hint

Follow the flow: sub_dep's return affects main_dep's return, which endpoint uses.

Concept Snapshot

FastAPI Sub-dependencies:
- Define a sub-dependency function.
- Use Depends(sub_dep) inside main dependency.
- Main dependency uses sub-dependency's output.
- Endpoint depends on main dependency.
- Enables clean, reusable dependency chains.

Full Transcript

In FastAPI, sub-dependencies allow one dependency to use another. When a request comes in, the endpoint calls the main dependency. The main dependency calls the sub-dependency to get a value. The sub-dependency returns its value, which the main dependency uses to build its own return value. Finally, the endpoint receives this value and sends it as a response. This chain helps organize code by breaking dependencies into smaller parts.

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