Depends function basics in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Depends function from FastAPI.

FastAPI

from fastapi import [1]

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

AResponse

BRequest

CDepends

DPath

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Depends from fastapi.security instead of fastapi

Using Request or Response instead of Depends

The Depends function is imported from FastAPI to declare dependencies in your path operation functions.

2fill in blank

medium

Complete the code to declare a dependency function that returns a fixed string.

FastAPI

def get_token():
    return [1]

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

A'token123'

B12345

Ctoken123

D"token123"

Attempts:

3 left

💡 Hint

Common Mistakes

Returning an unquoted string which causes a NameError

Returning a number instead of a string

The dependency function should return a string literal, so it must be quoted.

3fill in blank

hard

Fix the error in the FastAPI path operation to use Depends correctly.

FastAPI

from fastapi import FastAPI, Depends

app = FastAPI()

def get_token():
    return "token123"

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

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

Aget_token()

BDepends(get_token)

CDepends(get_token())

Dget_token

Attempts:

3 left

💡 Hint

Common Mistakes

Calling the dependency function inside Depends

Passing the function without Depends

When declaring a dependency, you pass the function itself to Depends without calling it.

4fill in blank

hard

Fill both blanks to create a dependency that extracts a query parameter named 'q'.

FastAPI

from fastapi import Query

def get_query(q: str = [1]):
    return q

@app.get("/search")
async def search(query: str = [2]):
    return {"query": query}

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

AQuery(None)

BDepends(get_query)

CQuery(...)

DDepends(Query)

Attempts:

3 left

💡 Hint

Common Mistakes

Using Depends(Query) which is invalid

Using Query(None) which makes the parameter optional

Use Query(...) to declare a required query parameter, and use Depends(get_query) to inject the dependency.

5fill in blank

hard

Fill all three blanks to create a dependency that reads a header and uses it in a path operation.

FastAPI

from fastapi import Header, Depends

async def get_user_agent(user_agent: str = [1]):
    return user_agent

@app.get("/info")
async def info(agent: str = [2]):
    return {"User-Agent": [3]

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

AHeader(None)

BDepends(get_user_agent)

Cagent

DHeader(...)

Attempts:

3 left

💡 Hint

Common Mistakes

Using Header(None) which makes the header optional

Returning the wrong variable name in the response

Use Header(...) to require the header, Depends(get_user_agent) to inject the dependency, and return the parameter agent in the response.

Practice

1. What is the main purpose of the Depends function in FastAPI?

easy

A. To create HTML templates

B. To define database models

C. To inject dependencies automatically into path operation functions

D. To handle HTTP status codes

Solution

1. Step 1: Understand what Depends does

   Depends is used to declare dependencies that FastAPI will automatically provide to your route functions.

2. Step 2: Identify the main use case

   It helps inject reusable code like authentication, database sessions, or other shared logic into routes.

3. Final Answer:

   To inject dependencies automatically into path operation functions -> Option C

4. Quick Check:

   Depends injects dependencies = C [OK]

Hint: Depends injects reusable code into routes automatically [OK]

Common Mistakes:

• Confusing Depends with database or template functions
• Thinking Depends handles HTTP status codes
• Assuming Depends creates models

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

easy

A. def read_items(db=Depends(get_db)): pass

B. def read_items(db: Depends(get_db)): pass

C. def read_items(db: Depends = get_db): pass

D. def read_items(db=Depends): pass

Solution

1. Step 1: Recall Depends syntax

   The correct syntax is to assign the parameter a default value of Depends with the dependency function inside.

2. Step 2: Match the correct option

   def read_items(db=Depends(get_db)): pass uses db=Depends(get_db), which is the proper way to declare a dependency.

3. Final Answer:

   def read_items(db=Depends(get_db)): pass -> Option A

4. Quick Check:

   Depends usage = parameter=Depends(function) [OK]

Hint: Use parameter=Depends(function) to declare dependencies [OK]

Common Mistakes:

• Using type annotation instead of default value for Depends
• Passing Depends without parentheses
• Assigning Depends without a function

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

from fastapi import FastAPI, Depends

app = FastAPI()

def get_number():
    return 42

@app.get('/items/')
def read_items(number: int = Depends(get_number)):
    return {"number": number}

medium

A. {"number": "get_number"}

B. {"number": 42}

C. Error: missing required parameter

D. {"number": null}

Solution

1. Step 1: Understand dependency injection

   The get_number function returns 42, and FastAPI injects this value into the number parameter.

2. Step 2: Check the returned response

   The route returns a dictionary with key "number" and value 42, so the output is {"number": 42}.

3. Final Answer:

   {"number": 42} -> Option B

4. Quick Check:

   Depends injects 42 = {"number": 42} [OK]

Hint: Depends calls function and injects return value [OK]

Common Mistakes:

• Expecting the function name instead of its return value
• Thinking parameter is missing if not passed explicitly
• Assuming null is returned if no argument given

4. What is wrong with the following FastAPI code using Depends? How to fix it?

from fastapi import FastAPI, Depends

app = FastAPI()

def get_user():
    return "Alice"

@app.get('/user/')
def read_user(user: str = Depends):
    return {"user": user}

medium

A. Depends is missing the dependency function; fix by using Depends(get_user)

B. The route path is invalid; fix by changing '/user/' to '/users/'

C. The return type is wrong; fix by returning a list instead of dict

D. The function get_user should accept parameters; fix by adding parameters

Solution

1. Step 1: Identify the Depends usage error

   The parameter uses Depends without specifying the dependency function, which is incorrect.

2. Step 2: Correct the Depends syntax

   It should be Depends(get_user) to tell FastAPI which function to call for the dependency.

3. Final Answer:

   Depends is missing the dependency function; fix by using Depends(get_user) -> Option A

4. Quick Check:

   Depends needs function argument = Depends(get_user) [OK]

Hint: Always pass the dependency function inside Depends() [OK]

Common Mistakes:

• Using Depends without parentheses or function
• Changing route path unnecessarily
• Changing return type without reason

5. How can you use Depends to share a database session across multiple routes without repeating code? Choose the best approach.

hard

A. Use Depends without any function to automatically get the session

B. Pass the session as a global variable to all routes

C. Manually create a session inside each route function

D. Create a function that returns the session and use Depends on it in each route

Solution

1. Step 1: Understand code reuse with Depends

   Depends allows you to write a function that creates or yields a database session once and injects it wherever needed.

2. Step 2: Identify the best practice

   Creating a session function and using Depends on it in routes avoids repetition and manages session lifecycle cleanly.

3. Final Answer:

   Create a function that returns the session and use Depends on it in each route -> Option D

4. Quick Check:

   Use Depends with session function for reuse = D [OK]

Hint: Use Depends with a session function to share DB session [OK]

Common Mistakes:

• Using global variables for sessions (not safe)
• Creating sessions manually in every route (repetitive)
• Using Depends without specifying a function