Multiple response types in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import FastAPI and create an app instance.

FastAPI

from fastapi import [1]
app = [1]()

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

ADepends

BRequest

CResponse

DFastAPI

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Request or Response instead of FastAPI.

Forgetting to call FastAPI() to create the app.

The FastAPI class is imported and used to create the app instance.

2fill in blank

medium

Complete the code to define a GET endpoint that returns JSON.

FastAPI

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return [1]

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

A"Hello"

B{"item_id": item_id}

Citem_id

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a plain string instead of a dict.

Returning just the integer item_id.

The endpoint returns a dictionary which FastAPI converts to JSON.

3fill in blank

hard

Fix the error in the response type by completing the code to return a plain text response.

FastAPI

from fastapi.responses import [1]

@app.get("/plaintext")
async def get_plaintext():
    return [1]("Hello World")

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

APlainTextResponse

BJSONResponse

CHTMLResponse

DRedirectResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Using JSONResponse which returns JSON.

Using HTMLResponse which returns HTML content.

Use PlainTextResponse to return plain text content.

4fill in blank

hard

Fill both blanks to return an HTML response with a custom status code.

FastAPI

from fastapi.responses import [1]

@app.get("/custom_html")
async def custom_html():
    content = "<h1>Welcome</h1>"
    return [1](content=content, status_code=[2])

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

AHTMLResponse

BPlainTextResponse

C200

D404

Attempts:

3 left

💡 Hint

Common Mistakes

Using PlainTextResponse for HTML content.

Using status code 200 when a custom code is needed.

Use HTMLResponse to return HTML content and set status_code=404 for custom status.

5fill in blank

hard

Fill all three blanks to return a JSON response with a custom header and status code.

FastAPI

from fastapi.responses import [1]

@app.get("/custom_json")
async def custom_json():
    data = {"message": "Success"}
    headers = [2]
    return [1](content=data, status_code=[3], headers=headers)

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

AJSONResponse

B{"X-Custom-Header": "Value"}

C201

DPlainTextResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Using PlainTextResponse instead of JSONResponse.

Passing headers as a string instead of a dictionary.

Use JSONResponse to return JSON data, add custom headers as a dict, and set status code 201 for Created.

Practice

1. What is the main purpose of using multiple response types in a FastAPI route?

easy

A. To speed up the API response time by caching

B. To allow the API to send different response formats based on conditions

C. To restrict the API to only one response format

D. To automatically generate database schemas

Solution

1. Step 1: Understand response types in FastAPI

   Multiple response types let an API send different formats like JSON or HTML depending on the request or logic.

2. Step 2: Identify the purpose

   This flexibility helps clients get the response format they expect or need.

3. Final Answer:

   To allow the API to send different response formats based on conditions -> Option B

4. Quick Check:

   Multiple response types = different formats [OK]

Hint: Multiple response types mean flexible output formats [OK]

Common Mistakes:

• Thinking it speeds up response time
• Believing it restricts to one format
• Confusing with database schema generation

2. Which of the following is the correct way to declare multiple response types in a FastAPI route decorator?

easy

A. @app.get('/items', responses={200: {'content': {'application/json': {}}}})

B. @app.get('/items', response_formats=['json', 'html'])

C. @app.get('/items', response_type=['json', 'html'])

D. @app.get('/items', responses={200: {'content': {'application/json': {}, 'text/html': {}}}})

Solution

1. Step 1: Review FastAPI response declaration syntax

   FastAPI uses the 'responses' parameter with status codes and content types as keys.

2. Step 2: Identify correct syntax for multiple types

   @app.get('/items', responses={200: {'content': {'application/json': {}, 'text/html': {}}}}) correctly shows multiple content types under the 200 status code.

3. Final Answer:

   @app.get('/items', responses={200: {'content': {'application/json': {}, 'text/html': {}}}}) -> Option D

4. Quick Check:

   responses param with content dict = @app.get('/items', responses={200: {'content': {'application/json': {}, 'text/html': {}}}}) [OK]

Hint: Use 'responses' with content dict for multiple types [OK]

Common Mistakes:

• Using non-existent parameters like response_type
• Declaring only one content type when multiple needed
• Incorrect dictionary structure in responses

3. Given this FastAPI route, what will be the response content type if return HTMLResponse(content='Hello') is used?

from fastapi import FastAPI
from fastapi.responses import JSONResponse, HTMLResponse

app = FastAPI()

@app.get('/greet', responses={200: {'content': {'application/json': {}, 'text/html': {}}}})
async def greet(html: bool = False):
    if html:
        return HTMLResponse(content='Hello')
    return JSONResponse(content={'message': 'Hello'})

medium

A. text/html

B. application/json

C. application/xml

D. text/plain

Solution

1. Step 1: Check the return type when html=True

   The function returns HTMLResponse with content 'Hello' when html is True.

2. Step 2: Identify the content type of HTMLResponse

   HTMLResponse sets the content type to 'text/html'.

3. Final Answer:

   text/html -> Option A

4. Quick Check:

   HTMLResponse = text/html [OK]

Hint: HTMLResponse means content type text/html [OK]

Common Mistakes:

• Assuming JSONResponse is always returned
• Confusing content type with return value
• Ignoring the condition that triggers HTMLResponse

4. Identify the error in this FastAPI route that tries to return multiple response types:

from fastapi import FastAPI
from fastapi.responses import JSONResponse, PlainTextResponse

app = FastAPI()

@app.get('/data', responses={200: {'content': {'application/json': {}, 'text/plain': {}}}})
async def data(response_type: str):
    if response_type == 'json':
        return JSONResponse(content={'key': 'value'})
    else:
        return 'Just plain text'

medium

A. responses dictionary is incorrectly formatted

B. Missing import for PlainTextResponse

C. Returning a plain string instead of a Response object for plain text

D. Function should not be async

Solution

1. Step 1: Check return types in the function

   When response_type is not 'json', the function returns a plain string instead of a Response object.

2. Step 2: Understand FastAPI response requirements

   FastAPI expects a Response object like PlainTextResponse for non-JSON responses to set headers correctly.

3. Final Answer:

   Returning a plain string instead of a Response object for plain text -> Option C

4. Quick Check:

   Plain string return needs PlainTextResponse [OK]

Hint: Return Response objects, not raw strings for non-JSON [OK]

Common Mistakes:

• Returning raw strings instead of Response objects
• Ignoring response content type headers
• Assuming async is not needed

5. You want a FastAPI route to return JSON by default but HTML if a query parameter ?format=html is given. Which approach correctly implements this with multiple response types?

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, HTMLResponse

app = FastAPI()

@app.get('/info', responses={200: {'content': {'application/json': {}, 'text/html': {}}}})
async def info(request: Request):
    format = request.query_params.get('format')
    if format == 'html':
        # What to return here?
    else:
        return JSONResponse(content={'info': 'data'})

hard

A. return HTMLResponse(content='Info')

B. return {'info': 'Info'}

C. return JSONResponse(content={'info': 'Info'})

D. return Response(content='Info', media_type='application/json')

Solution

1. Step 1: Check the condition for HTML format

   If the query parameter 'format' equals 'html', the route should return an HTML response.

2. Step 2: Use the correct response class for HTML

   HTMLResponse sets the content type to 'text/html' and sends HTML content properly.

3. Final Answer:

   return HTMLResponse(content='<h1>Info</h1>') -> Option A

4. Quick Check:

   HTMLResponse for HTML output = return HTMLResponse(content='<h1>Info</h1>') [OK]

Hint: Use HTMLResponse to send HTML content explicitly [OK]

Common Mistakes:

• Returning dict with HTML string instead of HTMLResponse
• Using JSONResponse with HTML content type
• Setting wrong media_type in Response