Response model declaration in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a response model in FastAPI.

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.get("/items/{item_id}", response_model=[1])
def read_item(item_id: int):
    return {"name": "Foo", "price": 42.0}

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

Aint

BItem

Cstr

Dfloat

Attempts:

3 left

💡 Hint

Common Mistakes

Using basic types like int or str instead of a Pydantic model.

Forgetting to import or define the model.

The response_model parameter expects a Pydantic model class that defines the response schema. Here, 'Item' is the correct model.

2fill in blank

medium

Complete the code to specify a response model for a POST endpoint.

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    username: str
    email: str

@app.post("/users/", response_model=[1])
def create_user(user: User):
    return user

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

Adict

Bstr

Clist

DUser

Attempts:

3 left

💡 Hint

Common Mistakes

Using basic types like dict or list instead of the Pydantic model.

Not matching the response_model to the returned data.

The response_model should be the Pydantic model that describes the response data, which is 'User' here.

3fill in blank

hard

Fix the error in the response model declaration.

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Product(BaseModel):
    id: int
    name: str

@app.get("/products/{product_id}", response_model=[1])
def get_product(product_id: int):
    return {"id": product_id, "name": "Gadget"}

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

AProduct

Bdict

Cint

Dstr

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'dict' or primitive types as response_model.

Mismatch between response_model and returned data structure.

The response_model must be the Pydantic model 'Product' to match the returned dictionary structure.

4fill in blank

hard

Fill both blanks to declare a response model and import the needed class.

FastAPI

from fastapi import FastAPI
from pydantic import [1]

app = FastAPI()

class Order([2]):
    order_id: int
    item: str

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

ABaseModel

BFastAPI

CRequest

DResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Importing or inheriting from FastAPI or other unrelated classes.

Forgetting to import BaseModel.

The Pydantic BaseModel must be imported and used as the base class for the model.

5fill in blank

hard

Fill all three blanks to declare a response model, import BaseModel, and use it as base class.

FastAPI

from fastapi import FastAPI
from pydantic import [1]

app = FastAPI()

class Customer([2]):
    id: int
    name: str

@app.get("/customers/{customer_id}", response_model=[3])
def get_customer(customer_id: int):
    return {"id": customer_id, "name": "Alice"}

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

ABaseModel

BFastAPI

CCustomer

DRequest

Attempts:

3 left

💡 Hint

Common Mistakes

Using FastAPI or Request instead of BaseModel.

Using wrong response_model name.

Import BaseModel, inherit Customer from BaseModel, and use Customer as response_model.

Practice

1. What is the main purpose of declaring a response_model in a FastAPI route?

easy

A. To handle incoming request validation

B. To define the shape and type of data the API sends back to the client

C. To set the HTTP status code for the response

D. To specify the database model used for storing data

Solution

1. Step 1: Understand response_model role

   The response_model tells FastAPI what data shape to send back, ensuring output matches a defined structure.

2. Step 2: Differentiate from other parameters

   It does not set status codes, validate requests, or define database models, which are separate concerns.

3. Final Answer:

   To define the shape and type of data the API sends back to the client -> Option B

4. Quick Check:

   response_model defines output data shape = D [OK]

Hint: Response model controls output data shape, not input or status [OK]

Common Mistakes:

• Confusing response_model with request body validation
• Thinking response_model sets HTTP status codes
• Assuming response_model defines database schema

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

easy

A. @app.get('/items', model_response=Item)

B. @app.get('/items', response=Item)

C. @app.get('/items', responseModel=Item)

D. @app.get('/items', response_model=Item)

Solution

1. Step 1: Recall FastAPI syntax for response model

   The correct parameter name is response_model in the route decorator.

2. Step 2: Check each option

   Only @app.get('/items', response_model=Item) uses the exact correct syntax response_model=Item. Others use incorrect parameter names.

3. Final Answer:

   @app.get('/items', response_model=Item) -> Option D

4. Quick Check:

   Correct parameter name is response_model = C [OK]

Hint: Use exact parameter name 'response_model' in route decorator [OK]

Common Mistakes:

• Using wrong parameter names like response or model_response
• Capitalizing parameter names incorrectly
• Omitting the response_model parameter

3. Given this FastAPI code snippet, what will be the output JSON when calling /user/1?

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    id: int
    name: str
    password: str

@app.get('/user/{user_id}', response_model=User)
def get_user(user_id: int):
    return {"id": user_id, "name": "Alice", "password": "secret", "token": "abc123"}

medium

A. {"id": 1, "name": "Alice"}

B. {"id": 1, "name": "Alice", "password": "secret", "token": "abc123"}

C. {"id": 1, "name": "Alice", "password": "secret"}

D. Runtime error due to extra field

Solution

1. Step 1: Understand response_model filtering

   The response_model=User tells FastAPI to return only fields defined in User model, ignoring extra fields like token.

2. Step 2: Analyze returned dictionary

   The returned dict has id, name, password, and extra token. The extra token is removed in output.

3. Final Answer:

   {"id": 1, "name": "Alice", "password": "secret"} -> Option C

4. Quick Check:

   response_model filters extra fields = A [OK]

Hint: Response model hides fields not declared in model [OK]

Common Mistakes:

• Expecting extra fields to appear in output
• Thinking extra fields cause errors
• Confusing input validation with output filtering

4. Identify the error in this FastAPI route declaration:

@app.get('/products', response_model=Product)
def get_products():
    return [{"id": 1, "name": "Book"}, {"id": 2, "name": "Pen"}]

Assuming Product is a Pydantic model for a single product.

medium

A. The route returns a list but response_model expects a single Product instance

B. The response_model parameter is missing

C. The function should return a dictionary, not a list

D. The route path should be '/product' not '/products'

Solution

1. Step 1: Check return type vs response_model

   The function returns a list of products, but response_model=Product expects a single product instance.

2. Step 2: Identify mismatch consequences

   This mismatch causes FastAPI to raise a validation error or incorrect output because the response model does not match the returned data type.

3. Final Answer:

   The route returns a list but response_model expects a single Product instance -> Option A

4. Quick Check:

   response_model type must match returned data type = A [OK]

Hint: Match response_model type exactly to returned data type [OK]

Common Mistakes:

• Returning list but using single model as response_model
• Ignoring type mismatch errors
• Assuming route path affects response_model

5. You want to return a list of users but only expose their id and name fields, hiding email and password. Given this User model:

class User(BaseModel):
    id: int
    name: str
    email: str
    password: str

Which is the best way to declare the response model in your route to achieve this?

hard

A. Create a new Pydantic model with only id and name, then use it as response_model

B. Use response_model=User and rely on FastAPI to hide email and password automatically

C. Return a dict with only id and name and use response_model=User

D. Set response_model=None and manually filter fields in the return

Solution

1. Step 1: Understand response_model controls output fields

   FastAPI uses the response_model to decide which fields to include in the output. Using the full User model will include all fields.

2. Step 2: Create a new model with only desired fields

   To hide email and password, define a new Pydantic model with only id and name and use it as the response_model.

3. Final Answer:

   Create a new Pydantic model with only id and name, then use it as response_model -> Option A

4. Quick Check:

   Use tailored model to expose only needed fields = B [OK]

Hint: Use a separate model with only fields to expose as response_model [OK]

Common Mistakes:

• Expecting FastAPI to hide fields automatically without a tailored model
• Returning partial dict but using full model as response_model
• Setting response_model=None and filtering manually (less safe)