Streaming responses in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the correct class for streaming responses in FastAPI.

FastAPI

from fastapi import FastAPI
from fastapi.responses import [1]

app = FastAPI()

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

AHTMLResponse

BJSONResponse

CRedirectResponse

DStreamingResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Using JSONResponse or HTMLResponse which are for full responses, not streaming.

Forgetting to import StreamingResponse.

The StreamingResponse class is used in FastAPI to send streaming data as a response.

2fill in blank

medium

Complete the code to define a generator function that yields streaming data.

FastAPI

def event_stream():
    for i in range(3):
        yield f"data: Message [1]\n\n"

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

Ai

Brange

Cevent

Dmessage

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable not defined in the loop.

Forgetting to include the loop variable in the string.

The variable i is used in the loop and should be included in the yielded string.

3fill in blank

hard

Fix the error in the FastAPI endpoint to return a streaming response.

FastAPI

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

def generate():
    yield "Hello\n"

@app.get("/stream")
async def stream():
    return [1](generate(), media_type="text/plain")

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

AResponse

BStreamingResponse

CJSONResponse

DHTMLResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Returning JSONResponse or Response which do not stream data.

Forgetting to wrap the generator with StreamingResponse.

The endpoint must return a StreamingResponse to stream data properly.

4fill in blank

hard

Fill both blanks to create a streaming response that streams numbers as bytes.

FastAPI

def number_stream():
    for num in range(1, 4):
        yield str(num).[1]()

@app.get("/numbers")
async def numbers():
    return [2](number_stream(), media_type="application/octet-stream")

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

Aencode

Bdecode

CStreamingResponse

Dformat

Attempts:

3 left

💡 Hint

Common Mistakes

Using decode instead of encode.

Forgetting to convert strings to bytes before streaming.

The numbers must be converted to bytes by calling encode(). The streaming response class is StreamingResponse.

5fill in blank

hard

Fill all three blanks to create a streaming response with a custom header and chunk size.

FastAPI

from fastapi.responses import StreamingResponse

async def custom_stream():
    yield b"chunk1"
    yield b"chunk2"

@app.get("/custom")
async def custom():
    headers = {"X-Custom-Header": "Value"}
    return StreamingResponse(custom_stream(), media_type=[1], headers=[2], chunk_size=[3])

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

A"application/octet-stream"

Bheaders

C1024

D"text/plain"

Attempts:

3 left

💡 Hint

Common Mistakes

Using text/plain for binary data.

Passing headers as a string instead of a dictionary.

Omitting chunk_size or using an invalid value.

The media type for binary data is application/octet-stream. The headers dictionary must be passed as is. The chunk size is set to 1024 bytes for streaming.

Practice

1. What is the main benefit of using StreamingResponse in FastAPI?

easy

A. It compresses the entire response into a single file.

B. It automatically caches all responses for faster access.

C. It converts JSON data into XML format before sending.

D. It sends data in small parts instead of all at once, improving efficiency.

Solution

1. Step 1: Understand what streaming means

   Streaming sends data in chunks, not all at once, which helps with large data or slow connections.

2. Step 2: Identify the role of StreamingResponse

   FastAPI's StreamingResponse helps send these chunks efficiently to the client.

3. Final Answer:

   It sends data in small parts instead of all at once, improving efficiency. -> Option D

4. Quick Check:

   Streaming = sending data in parts [OK]

Hint: Streaming sends data bit by bit, not all at once [OK]

Common Mistakes:

• Thinking StreamingResponse caches data
• Confusing streaming with data compression
• Assuming it changes data format automatically

2. Which of the following is the correct way to import StreamingResponse in FastAPI?

easy

A. from fastapi import StreamingResponse

B. import StreamingResponse from fastapi.responses

C. from fastapi.responses import StreamingResponse

D. import StreamingResponse as sr from fastapi

Solution

1. Step 1: Recall FastAPI import syntax

   FastAPI uses standard Python import syntax: from module import class/function.

2. Step 2: Identify correct module for StreamingResponse

   StreamingResponse is in fastapi.responses, so correct import is from fastapi.responses import StreamingResponse.

3. Final Answer:

   from fastapi.responses import StreamingResponse -> Option C

4. Quick Check:

   Correct import = from fastapi.responses import StreamingResponse [OK]

Hint: Use 'from fastapi.responses import StreamingResponse' [OK]

Common Mistakes:

• Using incorrect import syntax like 'import StreamingResponse from ...'
• Importing directly from 'fastapi' instead of 'fastapi.responses'
• Trying to alias import incorrectly

3. Given this FastAPI endpoint code, what will the client receive?

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

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

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

medium

A. A streamed response sending 'Number: 0\n', then 'Number: 1\n', then 'Number: 2\n' in parts

B. A single response with 'Number: 0\nNumber: 1\nNumber: 2\n' all at once

C. Three separate responses, each with one number

D. An error because StreamingResponse cannot use generators

Solution

1. Step 1: Understand the generator function

   The function generate_numbers yields strings one by one for i in 0 to 2.

2. Step 2: Analyze StreamingResponse behavior

   StreamingResponse sends data chunks as they are yielded, so client receives parts streamed.

3. Final Answer:

   A streamed response sending 'Number: 0\n', then 'Number: 1\n', then 'Number: 2\n' in parts -> Option A

4. Quick Check:

   Generator + StreamingResponse = streamed chunks [OK]

Hint: Generators yield chunks; StreamingResponse streams them [OK]

Common Mistakes:

• Thinking all data sends at once
• Expecting multiple separate HTTP responses
• Assuming StreamingResponse rejects generators

4. Identify the error in this FastAPI streaming endpoint code:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

def stream_data():
    data = ["a", "b", "c"]
    for d in data:
        return d

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

medium

A. The function stream_data uses return inside the loop instead of yield.

B. StreamingResponse requires media_type to be 'application/json'.

C. The endpoint path should be '/stream_data' not '/stream'.

D. FastAPI does not support StreamingResponse with string data.

Solution

1. Step 1: Check stream_data function logic

   Inside the loop, return exits the function immediately, so only first item 'a' is returned.

2. Step 2: Understand streaming requires yield

   StreamingResponse expects an iterable or generator; yield produces chunks one by one.

3. Final Answer:

   The function stream_data uses return inside the loop instead of yield. -> Option A

4. Quick Check:

   Use yield, not return, for streaming generators [OK]

Hint: Use yield inside loops for streaming, not return [OK]

Common Mistakes:

• Using return inside generator loops
• Wrong media_type for StreamingResponse
• Confusing endpoint path naming
• Believing StreamingResponse can't stream strings

5. You want to stream a large CSV file line by line using FastAPI. Which approach correctly combines streaming with file reading?

hard

A. Use StreamingResponse with a function that returns the file size.

B. Use a generator that opens the file and yields each line, then return StreamingResponse with that generator.

C. Return StreamingResponse with the file path string directly.

D. Read the entire file into memory, then return StreamingResponse with a list of lines.

Solution

1. Step 1: Understand streaming large files

   Reading line by line with a generator avoids loading whole file into memory.

2. Step 2: Match StreamingResponse usage

   StreamingResponse accepts an iterable like a generator that yields file lines.

3. Step 3: Evaluate options

   Use a generator that opens the file and yields each line, then return StreamingResponse with that generator. This uses a generator to yield lines, which is efficient and correct. Others either load all data or misuse StreamingResponse.

4. Final Answer:

   Use a generator that opens the file and yields each line, then return StreamingResponse with that generator. -> Option B

5. Quick Check:

   Generator + StreamingResponse = efficient file streaming [OK]

Hint: Stream files by yielding lines in a generator [OK]

Common Mistakes:

• Loading entire file into memory before streaming
• Passing file path string instead of iterable
• Returning file size instead of content