Streaming responses in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this FastAPI streaming response output?

Consider this FastAPI endpoint that streams numbers as text lines. What will the client receive when calling this endpoint?

FastAPI

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import asyncio

app = FastAPI()

async def number_stream():
    for i in range(3):
        yield f"Number: {i}\n"
        await asyncio.sleep(0.1)

@app.get("/numbers")
async def stream_numbers():
    return StreamingResponse(number_stream(), media_type="text/plain")

A The client receives a JSON array ["Number: 0", "Number: 1", "Number: 2"] all at once.

B The client receives a streamed response with lines: 'Number: 0', 'Number: 1', 'Number: 2' each followed by a newline, arriving with small delays.

C The client receives a single string 'Number: 0Number: 1Number: 2' without newlines or delays.

D The client receives an error because StreamingResponse cannot stream async generators.

💡 Hint

Think about what StreamingResponse does with an async generator and the media type.

StreamingResponse sends data chunks as they are yielded. Here, each 'Number: i\n' is sent with a small delay, so the client receives lines one by one.

📝 Syntax

intermediate

Which option correctly creates a streaming response from a synchronous generator?

You want to stream data from a synchronous generator function in FastAPI. Which code snippet correctly wraps it for StreamingResponse?

FastAPI

def sync_generator():
    for i in range(3):
        yield f"data {i}\n"

A return StreamingResponse(sync_generator(), media_type="text/plain")

B return StreamingResponse(iter(sync_generator()), media_type="text/plain")

C return StreamingResponse(async_generator(sync_generator()), media_type="text/plain")

D return StreamingResponse(sync_generator, media_type="text/plain")

💡 Hint

StreamingResponse accepts any iterable or async iterable as first argument.

StreamingResponse can take a synchronous generator directly. Wrapping with iter() is redundant but valid; however, option A uses iter() on a generator function call which is already an iterator, so it's redundant but works. Option A calls undefined async_generator. Option A passes the function itself, not the generator object.

🔧 Debug

advanced

Why does this FastAPI streaming endpoint raise a RuntimeError?

Examine this code snippet. Why does it raise 'RuntimeError: async generator ignored' when called?

FastAPI

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

def sync_gen():
    yield "hello\n"

@app.get("/stream")
async def stream():
    return StreamingResponse(sync_gen(), media_type="text/plain")

A Because the sync generator yields strings instead of bytes.

B Because StreamingResponse expects an async generator but got a sync generator in an async endpoint.

C Because the endpoint is async but returns a sync generator without wrapping it in an async iterator.

D Because StreamingResponse requires the media_type to be 'application/octet-stream' for generators.

💡 Hint

Think about how async endpoints handle sync generators in StreamingResponse.

An async endpoint returning StreamingResponse with a sync generator causes FastAPI to try to iterate asynchronously, which fails. Wrapping the sync generator in an async iterator or making the endpoint sync fixes this.

❓ state_output

advanced

What is the output of this FastAPI streaming response with stateful generator?

Given this code, what will the client receive when calling /count?

FastAPI

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

class Counter:
    def __init__(self):
        self.count = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.count >= 3:
            raise StopIteration
        self.count += 1
        return f"Count: {self.count}\n"

@app.get("/count")
def count_stream():
    counter = Counter()
    return StreamingResponse(counter, media_type="text/plain")

A The client receives streamed lines: 'Count: 1', 'Count: 2', 'Count: 3' each followed by newline.

B The client receives a JSON array ["Count: 1", "Count: 2", "Count: 3"] all at once.

C The client receives a single string 'Count: 123' without newlines or streaming.

D The client receives an error because Counter is not an async iterable.

💡 Hint

StreamingResponse can stream from any iterable, including stateful ones.

Counter is a synchronous iterator yielding strings with newlines. StreamingResponse streams these strings one by one to the client.

🧠 Conceptual

expert

Which statement about FastAPI StreamingResponse and async generators is TRUE?

Select the correct statement about using StreamingResponse with async generators in FastAPI.

A StreamingResponse can only stream synchronous generators; async generators cause runtime errors.

B StreamingResponse automatically converts synchronous generators to async generators internally.

C StreamingResponse requires the async generator to be fully consumed before sending any data to the client.

D StreamingResponse can stream async generators, but the endpoint must be async and return the StreamingResponse directly without awaiting the generator.

💡 Hint

Consider how async generators and StreamingResponse interact in async endpoints.

StreamingResponse supports async generators and streams data as it is yielded. The endpoint must be async and return StreamingResponse without awaiting the generator itself.