Async generator dependencies in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an async generator dependency in FastAPI.

FastAPI

async def get_db():
    db = connect_to_db()
    try:
        yield [1]
    finally:
        db.close()

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

Adb

Bconnect_to_db()

Cawait db

Ddb.close()

Attempts:

3 left

💡 Hint

Common Mistakes

Yielding the function call instead of the connection object.

Calling close() before yielding.

The async generator yields the database connection object db so it can be used by the route handler.

2fill in blank

medium

Complete the code to use the async generator dependency in a FastAPI route.

FastAPI

from fastapi import Depends, FastAPI

app = FastAPI()

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

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

Aconnect_to_db

Bget_db

Cdb.close

Dyield_db

Attempts:

3 left

💡 Hint

Common Mistakes

Using the connection function instead of the dependency function.

Trying to call the dependency instead of passing it to Depends.

The route uses Depends(get_db) to inject the async generator dependency.

3fill in blank

hard

Fix the error in the async generator dependency by completing the code.

FastAPI

async def get_session():
    session = create_session()
    try:
        [1] session
    finally:
        await session.close()

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

Aawait

Breturn

Cyield from

Dyield

Attempts:

3 left

💡 Hint

Common Mistakes

Using return instead of yield in async generator.

Using await incorrectly before yield.

Async generator dependencies must use yield to provide the resource.

4fill in blank

hard

Fill both blanks to correctly define and use an async generator dependency with FastAPI.

FastAPI

async def get_resource():
    resource = await acquire_resource()
    try:
        [1] resource
    finally:
        await [2]

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

Ayield

Brelease_resource()

Cresource.close()

Dreturn

Attempts:

3 left

💡 Hint

Common Mistakes

Using return instead of yield.

Calling close() instead of the async release function.

The async generator yields the resource and then releases it asynchronously in the finally block.

5fill in blank

hard

Fill all three blanks to create a FastAPI route that depends on two async generator dependencies.

FastAPI

async def get_db():
    db = connect_db()
    try:
        [1] db
    finally:
        db.close()

async def get_cache():
    cache = await connect_cache()
    try:
        [2] cache
    finally:
        await cache.disconnect()

@app.get("/data/")
async def get_data(db = Depends([3]), cache = Depends(get_cache)):
    return {"db": str(db), "cache": str(cache)}

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

Ayield

Cget_db

Dreturn

Attempts:

3 left

💡 Hint

Common Mistakes

Using return instead of yield in generators.

Passing the wrong function to Depends.

Both async generators use yield to provide resources. The route depends on get_db and get_cache.

Practice

1. What is the main purpose of using an async generator dependency in FastAPI?

easy

A. To manage setup and cleanup actions around a request automatically

B. To speed up synchronous code execution

C. To replace all regular functions with asynchronous ones

D. To create infinite loops inside API endpoints

Solution

1. Step 1: Understand async generator dependencies

   Async generator dependencies use async def with yield to run setup code before yielding and cleanup code after.

2. Step 2: Identify their purpose in FastAPI

   This pattern is mainly used to manage resources safely, like opening and closing database connections around a request.

3. Final Answer:

   To manage setup and cleanup actions around a request automatically -> Option A

4. Quick Check:

   Async generator dependencies = setup + cleanup [OK]

Hint: Think setup before yield, cleanup after yield [OK]

Common Mistakes:

• Confusing async generators with normal async functions
• Thinking they speed up synchronous code
• Assuming they replace all functions

2. Which of the following is the correct syntax to define an async generator dependency in FastAPI?

easy

A. async def resource(): yield 'data'

B. def resource(): yield 'data'

C. async def resource(): return 'data'

D. def resource(): return 'data'

Solution

1. Step 1: Identify async generator syntax

   An async generator uses async def and yield inside the function body.

2. Step 2: Compare options

   async def resource(): yield 'data' uses async def and yield, which is correct. Options A and B are synchronous, and C uses return instead of yield.

3. Final Answer:

   async def resource(): yield 'data' -> Option A

4. Quick Check:

   Async + yield = async generator [OK]

Hint: Async generator = async def + yield inside [OK]

Common Mistakes:

• Using return instead of yield
• Forgetting async keyword
• Using synchronous def for async generator

3. Given this FastAPI async generator dependency, what will be printed when the endpoint is called?

async def resource():
    print('Setup')
    yield 'data'
    print('Cleanup')

@app.get('/')
async def read(resource=Depends(resource)):
    print('Inside endpoint')
    return resource

medium

A. Inside endpoint only

B. Inside endpoint, Setup, Cleanup

C. Setup, Cleanup, Inside endpoint

D. Setup, Inside endpoint, Cleanup

Solution

1. Step 1: Understand async generator flow

   When the endpoint is called, FastAPI runs the async generator up to the yield (prints 'Setup'), then runs the endpoint code (prints 'Inside endpoint'), then after response finishes, runs code after yield (prints 'Cleanup').

2. Step 2: Order of prints

   The prints happen in order: 'Setup', 'Inside endpoint', 'Cleanup'.

3. Final Answer:

   Setup, Inside endpoint, Cleanup -> Option D

4. Quick Check:

   Yield pauses, so Setup before, Cleanup after endpoint [OK]

Hint: Setup prints before yield, cleanup after endpoint runs [OK]

Common Mistakes:

• Assuming cleanup runs before endpoint
• Thinking yield returns immediately
• Ignoring async generator lifecycle

4. Identify the error in this async generator dependency code:

async def resource():
    connection = await connect_db()
    yield connection
    await connection.close()

@app.get('/')
async def read(conn=Depends(resource)):
    return {'status': 'ok'}

medium

A. Missing await before yield

B. Cannot yield inside async def

C. Not using try-finally to ensure cleanup

D. Depends should not be used with async generators

Solution

1. Step 1: Check resource cleanup safety

   Without try-finally, if an exception occurs, await connection.close() might not run, causing resource leaks.

2. Step 2: Proper pattern for async generator cleanup

   Use try-finally around yield to guarantee cleanup runs even on errors.

3. Final Answer:

   Not using try-finally to ensure cleanup -> Option C

4. Quick Check:

   Always use try-finally for cleanup in async generators [OK]

Hint: Use try-finally to guarantee cleanup after yield [OK]

Common Mistakes:

• Forgetting try-finally causes resource leaks
• Thinking yield needs await
• Believing Depends can't use async generators

5. You want to create an async generator dependency that opens a database connection, yields it, and ensures it closes even if the endpoint raises an error. Which code snippet correctly implements this?

hard

A. async def db():
conn = await open_db()
yield conn
await conn.close()

B. async def db():
conn = await open_db()
try:
yield conn
finally:
await conn.close()

C. async def db():
conn = await open_db()
yield conn
conn.close()

D. async def db():
conn = open_db()
yield conn
await conn.close()

Solution

1. Step 1: Ensure proper async resource management

   Opening the connection must be awaited, and closing must happen even if errors occur.

2. Step 2: Use try-finally around yield

   Only async def db(): conn = await open_db() try: yield conn finally: await conn.close() uses try-finally to guarantee await conn.close() runs after yield, even on exceptions.

3. Final Answer:

   async def db(): conn = await open_db() try: yield conn finally: await conn.close() -> Option B

4. Quick Check:

   Try-finally ensures cleanup after yield [OK]

Hint: Wrap yield in try-finally to always close resources [OK]

Common Mistakes:

• Not awaiting open_db()
• Not using try-finally for cleanup
• Calling close() without await