Shared dependencies in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a shared dependency function.

FastAPI

from fastapi import Depends

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

async def read_items(db = Depends([1])):
    return {"db": db}

Drag options to blanks, or click blank then click option'

Aread_items

BDepends

Cget_db

Ddb

Attempts:

3 left

💡 Hint

Common Mistakes

Passing Depends instead of the function name.

Using the variable name instead of the function name.

The shared dependency function get_db is passed to Depends to inject the database connection.

2fill in blank

medium

Complete the code to use the shared dependency in two endpoints.

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def get_token():
    return "token123"

@app.get("/items/")
async def read_items(token = Depends([1])):
    return {"token": token}

@app.get("/users/")
async def read_users(token = Depends(get_token)):
    return {"token": token}

Drag options to blanks, or click blank then click option'

Aread_items

BDepends

Ctoken

Dget_token

Attempts:

3 left

💡 Hint

Common Mistakes

Passing Depends instead of the function name.

Using the variable name instead of the function name.

The shared dependency function get_token is passed to Depends to inject the token in both endpoints.

3fill in blank

hard

Fix the error in the shared dependency usage.

FastAPI

from fastapi import Depends

def common_parameters(q: str = None):
    return {"q": q}

async def read_items(params = Depends([1])):
    return params

Drag options to blanks, or click blank then click option'

Acommon_parameters

Bcommon_parameters()

CDepends

Dparams

Attempts:

3 left

💡 Hint

Common Mistakes

Calling the function inside Depends with parentheses.

Passing Depends itself instead of the function.

When passing a dependency function to Depends, do not call it with parentheses. Just pass the function name.

4fill in blank

hard

Fill both blanks to create a shared dependency with a class and use it in an endpoint.

FastAPI

from fastapi import Depends, FastAPI

class CommonQuery:
    def __init__(self, q: str = None):
        self.q = q

app = FastAPI()

@app.get("/items/")
async def read_items(commons: CommonQuery = Depends([1])):
    return {"query": commons.[2]

Drag options to blanks, or click blank then click option'

ACommonQuery

BDepends

Cq

Dquery

Attempts:

3 left

💡 Hint

Common Mistakes

Passing Depends instead of the class name.

Accessing a wrong attribute name.

The class CommonQuery is passed to Depends to create a shared dependency. The attribute q holds the query string.

5fill in blank

hard

Fill all three blanks to create a shared dependency with a function and use it in two endpoints.

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def get_token_header(x_token: str = None):
    if x_token != "fake-super-secret-token":
        raise Exception("Invalid token")
    return x_token

@app.get("/items/")
async def read_items(token: str = Depends([1])):
    return {"token": token}

@app.get("/users/")
async def read_users(token: str = Depends([2])):
    return {"token": token}

# Use the shared dependency function [3] in both endpoints

Drag options to blanks, or click blank then click option'

Aget_token_header

BDepends

Dread_items

Attempts:

3 left

💡 Hint

Common Mistakes

Passing Depends instead of the function name.

Using different or wrong function names.

The shared dependency function get_token_header is passed to Depends in both endpoints to check the token.

Practice

1. What is the main purpose of using Depends() in FastAPI for shared dependencies?

easy

A. To reuse code across multiple routes by declaring common dependencies

B. To create a new route in the application

C. To handle database connections manually

D. To define the response model for an endpoint

Solution

1. Step 1: Understand the role of Depends()

   Depends() is used in FastAPI to declare dependencies that can be shared across multiple routes.

2. Step 2: Identify the main benefit

   Using shared dependencies helps reuse code and keep the app clean and maintainable.

3. Final Answer:

   To reuse code across multiple routes by declaring common dependencies -> Option A

4. Quick Check:

   Shared dependencies = reuse code [OK]

Hint: Depends() means shared code for many routes [OK]

Common Mistakes:

• Thinking Depends() creates routes
• Confusing Depends() with response models
• Assuming Depends() manages database connections directly

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

easy

A. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass

B. def get_db(): return Session(); @app.get('/items') def read_items(db=get_db()): pass

C. def get_db(): return Session(); @app.get('/items') def read_items(db: Session): pass

D. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends()): pass

Solution

1. Step 1: Review correct dependency syntax

   In FastAPI, dependencies are declared using Depends(function_name) inside the function parameters.

2. Step 2: Check each option

   def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass correctly uses db=Depends(get_db). def get_db(): return Session(); @app.get('/items') def read_items(db=get_db()): pass calls the function directly, which is incorrect. def get_db(): return Session(); @app.get('/items') def read_items(db: Session): pass lacks Depends, so no injection happens. def get_db(): return Session(); @app.get('/items') def read_items(db=Depends()): pass uses Depends without a function, which is invalid.

3. Final Answer:

   def get_db(): return Session(); @app.get('/items') def read_items(db=Depends(get_db)): pass -> Option A

4. Quick Check:

   Depends() needs function inside [OK]

Hint: Depends() must wrap the dependency function [OK]

Common Mistakes:

• Calling dependency function directly in parameter
• Forgetting to use Depends() wrapper
• Using Depends() without specifying the function

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

from fastapi import FastAPI, Depends

app = FastAPI()

def common_dep():
    return "shared value"

@app.get('/items/{item_id}')
def read_item(item_id: int, value: str = Depends(common_dep)):
    return {"item_id": item_id, "value": value}

medium

A. Error: Missing required parameter 'value'

B. {"item_id": 42, "value": 42}

C. {"item_id": 42, "value": null}

D. {"item_id": 42, "value": "shared value"}

Solution

1. Step 1: Understand dependency injection

   The function common_dep returns the string "shared value". FastAPI injects this into the value parameter via Depends(common_dep).

2. Step 2: Check the returned JSON

   The route returns a dictionary with item_id from the path and value from the dependency. So the output will be {"item_id": 42, "value": "shared value"}.

3. Final Answer:

   {"item_id": 42, "value": "shared value"} -> Option D

4. Quick Check:

   Dependency injects "shared value" [OK]

Hint: Depends injects return value as parameter [OK]

Common Mistakes:

• Assuming dependency returns item_id
• Expecting error due to missing parameter
• Thinking value will be null without explicit call

4. Identify the error in the following FastAPI code using shared dependencies:

from fastapi import FastAPI, Depends

app = FastAPI()

def get_token():
    return "token123"

@app.get('/secure')
def secure_route(token: str = Depends()):
    return {"token": token}

medium

A. The function secure_route should not have parameters

B. The dependency function get_token() should return an int

C. Depends() is missing the dependency function inside

D. The route decorator is missing parentheses

Solution

1. Step 1: Check Depends usage

   The parameter token uses Depends() without specifying the dependency function. This is incorrect syntax.

2. Step 2: Correct usage

   Depends must wrap the function providing the dependency, so it should be Depends(get_token).

3. Final Answer:

   Depends() is missing the dependency function inside -> Option C

4. Quick Check:

   Depends() needs function argument [OK]

Hint: Depends() always needs a function inside [OK]

Common Mistakes:

• Using Depends() without argument
• Expecting Depends() to work without function
• Confusing Depends() with decorator syntax

5. You want to share a database session dependency across multiple routes but also ensure it closes after each request. Which approach correctly uses shared dependencies with cleanup in FastAPI?

hard

A. Create the session globally once and reuse it without closing

B. Use a dependency function with yield that creates the session, yields it, then closes it after

C. Pass the session as a normal parameter without Depends()

D. Use Depends() but close the session manually inside each route

Solution

1. Step 1: Understand dependency cleanup

   FastAPI supports dependencies with cleanup by using yield inside the dependency function. This allows setup before yield and cleanup after.

2. Step 2: Apply to database session

   The correct pattern is to create the session, yield it for use in routes, then close it after the request finishes.

3. Final Answer:

   Use a dependency function with yield that creates the session, yields it, then closes it after -> Option B

4. Quick Check:

   Yield in dependency = setup and cleanup [OK]

Hint: Use yield in dependency for setup and cleanup [OK]

Common Mistakes:

• Reusing global session without closing
• Closing session inside route instead of dependency
• Not using Depends() for session injection