Sub-dependencies in FastAPI - Mini Project: Build & Apply

Using Sub-dependencies in FastAPI

📖 Scenario: You are building a simple FastAPI app that needs to check user authentication and then get user details. To keep your code clean, you want to use sub-dependencies: one dependency to check authentication, and another that depends on it to get user info.

🎯 Goal: Build a FastAPI app with two dependencies: get_current_user that depends on verify_token. The app should have one route /profile that returns the current user's name.

📋 What You'll Learn

Create a dependency function called verify_token that returns a fixed token string.

Create a sub-dependency function called get_current_user that depends on verify_token and returns a dictionary with a name key.

Create a FastAPI app instance called app.

Create a GET route /profile that uses get_current_user as a dependency and returns the user's name.

💡 Why This Matters

🌍 Real World

In real apps, authentication and user info fetching are often done with dependencies. Sub-dependencies help organize these steps cleanly.

💼 Career

Understanding FastAPI dependencies and sub-dependencies is essential for backend developers building secure and maintainable APIs.

1

Create the verify_token dependency

Create a function called verify_token that returns the string 'secrettoken123'.

FastAPI

# Your code here

Hint

This function simulates checking a token and returns a fixed string.

2

Create the get_current_user sub-dependency

Create a function called get_current_user that takes a parameter token with a dependency on verify_token using Depends. It should return a dictionary {'name': 'Alice'}.

FastAPI

def verify_token():
    return 'secrettoken123'

from fastapi import Depends

# Your code here

Hint

Use Depends(verify_token) to declare the sub-dependency.

3

Create the FastAPI app instance

Import FastAPI and create an app instance called app.

FastAPI

def verify_token():
    return 'secrettoken123'

from fastapi import Depends

def get_current_user(token: str = Depends(verify_token)):
    return {'name': 'Alice'}

# Your code here

Hint

Remember to import FastAPI and create app = FastAPI().

4

Create the /profile route using the sub-dependency

Create a GET route /profile on app that uses get_current_user as a dependency with Depends. The route function should accept a parameter user and return {'user_name': user['name']}.

FastAPI

from fastapi import FastAPI, Depends

def verify_token():
    return 'secrettoken123'

from fastapi import Depends

def get_current_user(token: str = Depends(verify_token)):
    return {'name': 'Alice'}

app = FastAPI()

# Your code here

Hint

Use @app.get('/profile') and Depends(get_current_user) to inject the user.

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