Depends function basics in FastAPI - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the Depends function in FastAPI?

Depends is used to declare dependencies for path operation functions. It helps FastAPI know what extra data or logic to run before your endpoint code.

beginner

How do you use Depends to inject a dependency into a FastAPI path operation?

You add a function parameter with Depends(your_dependency_function). FastAPI calls that function and passes its result to your endpoint.

intermediate

Can Depends be used to share common logic like authentication or database sessions?

Yes! Depends is perfect for reusing code like checking user login or creating a database session before running your endpoint.

intermediate

What happens if a dependency function used with Depends raises an exception?

FastAPI stops running the endpoint and returns the error response immediately. This helps handle errors early, like unauthorized access.

advanced

Is it possible to have nested dependencies with Depends in FastAPI?

Yes, a dependency function can itself use Depends to call other dependencies. FastAPI resolves them all automatically.

What does Depends do in FastAPI?

A Defines a new API route

B Declares a dependency to be injected into a path operation

C Handles HTTP requests directly

D Creates database tables automatically

Depends tells FastAPI to run a function and pass its result as a parameter to your endpoint.

How do you tell FastAPI to use a dependency function named get_db?

A Add get_db() inside the endpoint code

B Import get_db but do not call it

C Use Depends(get_db) as a parameter in the endpoint function

D Call get_db in the main app startup

You add a parameter with Depends(get_db) so FastAPI calls get_db and passes its result.

What happens if a Depends dependency raises an HTTPException?

A FastAPI returns the error response immediately

B The endpoint runs normally

C The exception is ignored

D The server crashes

FastAPI stops the endpoint and returns the error response when a dependency raises HTTPException.

Can a dependency function use Depends to call another dependency?

A Yes, nested dependencies are supported

B Only if you use global variables

C No, dependencies cannot be nested

D Only in class-based views

FastAPI supports nested dependencies where one dependency calls another using Depends.

Which of these is a common use case for Depends?

A Creating database tables

B Defining HTML templates

C Writing CSS styles

D Sharing authentication logic

Depends is often used to share logic like authentication or database sessions across endpoints.

Explain how Depends works in FastAPI and why it is useful.

Think about how you can share common setup code for many endpoints.

Describe a scenario where nested dependencies with Depends would be helpful.

Consider when one setup step needs another to work first.

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