Request body declaration in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a request body parameter in FastAPI.

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

@app.post("/items/")
async def create_item(item: [1]):
    return item

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

AItem

BRequest

CBody

Dstr

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Request' instead of the Pydantic model.

Using 'Body' without importing or proper context.

Using primitive types like 'str' for complex data.

In FastAPI, to declare a request body, you define a Pydantic model (here, Item) and use it as the type of the parameter.

2fill in blank

medium

Complete the code to import the correct function to declare a request body explicitly.

FastAPI

from fastapi import FastAPI, [1]
from pydantic import BaseModel

app = FastAPI()

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

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

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

ADepends

BRequest

CBody

DForm

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Request' which is for the entire HTTP request, not just the body.

Using 'Depends' which is for dependency injection.

Using 'Form' which is for form data.

The Body function from FastAPI is used to explicitly declare a request body parameter with additional options.

3fill in blank

hard

Fix the error in the code to correctly declare a request body with a default value.

FastAPI

from fastapi import FastAPI, Body
from pydantic import BaseModel

app = FastAPI()

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

@app.post("/products/")
async def create_product(product: Product = [1]):
    return product

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

ABody()

BBody(default=...)

CBody(default=Product())

DBody(default=None)

Attempts:

3 left

💡 Hint

Common Mistakes

Using Body(default=None) which makes the body optional.

Using Body() without specifying required or default.

Trying to instantiate the model as default.

Using Body(default=...) tells FastAPI that this parameter is required in the request body.

4fill in blank

hard

Fill both blanks to declare a request body with an alias and description.

FastAPI

from fastapi import FastAPI, Body
from pydantic import BaseModel

app = FastAPI()

class Order(BaseModel):
    item_id: int
    quantity: int

@app.post("/orders/")
async def create_order(order: Order = Body([1], description=[2])):
    return order

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

A...

B'Order data'

C'order_data'

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using None instead of ... for required body.

Putting alias string in the first blank instead of description.

Not providing description string.

Using ... marks the body as required, and description adds helpful info for API docs.

5fill in blank

hard

Fill all three blanks to declare a request body with an alias, example, and minimum value validation.

FastAPI

from fastapi import FastAPI, Body
from pydantic import BaseModel, Field

app = FastAPI()

class Payment(BaseModel):
    amount: float = Field(..., gt=0)
    method: str

@app.post("/payments/")
async def create_payment(payment: Payment = Body(
    ...,
    alias=[1],
    example=[2],
    description=[3]
)):
    return payment

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

A'payment_info'

B{"amount": 100.0, "method": "credit_card"}

C"Payment details with positive amount"

D"payment"

Attempts:

3 left

💡 Hint

Common Mistakes

Using alias as a dictionary instead of string.

Not providing example as a dictionary.

Using description as a non-string.

The alias is a string used in the JSON key, example shows sample data, and description explains the parameter.

Practice

1. What is the main purpose of declaring a request body in FastAPI using a Pydantic model?

easy

A. To define the URL path for the API endpoint

B. To tell FastAPI what data structure to expect and validate from the client

C. To specify the HTTP method like GET or POST

D. To set the response status code

Solution

1. Step 1: Understand request body role

   The request body contains data sent by the client to the server, usually in POST or PUT requests.

2. Step 2: Role of Pydantic model in FastAPI

   Using a Pydantic model tells FastAPI the expected data shape and automatically validates it.

3. Final Answer:

   To tell FastAPI what data structure to expect and validate from the client -> Option B

4. Quick Check:

   Request body declaration = Data validation [OK]

Hint: Request body = data shape + validation [OK]

Common Mistakes:

• Confusing request body with URL path
• Thinking request body sets HTTP method
• Assuming request body controls response code

2. Which of the following is the correct way to declare a request body parameter in a FastAPI endpoint?

easy

A. def create_item(item: dict):

B. def create_item(item: BaseModel):

C. def create_item(item: Item):

D. def create_item(item: str):

Solution

1. Step 1: Recognize Pydantic model usage

   FastAPI expects a Pydantic model class (like Item) to declare request body parameters.

2. Step 2: Check each option

   def create_item(item: dict): uses dict which works but is not recommended; def create_item(item: BaseModel): uses BaseModel directly which is abstract; def create_item(item: Item): uses a user-defined model Item which is correct; def create_item(item: str): uses str which is not a model.

3. Final Answer:

   def create_item(item: Item): -> Option C

4. Quick Check:

   Use Pydantic model class for request body [OK]

Hint: Use your Pydantic model class as parameter type [OK]

Common Mistakes:

• Using dict instead of a Pydantic model
• Using BaseModel directly instead of subclass
• Using primitive types like str for complex data

3. Given this FastAPI code snippet, what will be the output if the client sends JSON {"name": "apple", "price": 5}?

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

medium

A. {"item_name": "apple", "item_price": "5"}

B. 500 Internal Server Error

C. ValidationError because price is int, not float

D. {"item_name": "apple", "item_price": 5.0}

Solution

1. Step 1: Understand Pydantic type conversion

   Pydantic automatically converts compatible types, so int 5 converts to float 5.0.

2. Step 2: Check returned dictionary

   The function returns a dict with keys "item_name" and "item_price" using the values from the item object.

3. Final Answer:

   {"item_name": "apple", "item_price": 5.0} -> Option D

4. Quick Check:

   Int converts to float automatically in Pydantic [OK]

Hint: Pydantic converts int to float automatically [OK]

Common Mistakes:

• Thinking int and float types cause validation error
• Expecting string instead of float for price
• Assuming server error on type mismatch

4. Identify the error in this FastAPI endpoint declaration:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    username: str
    age: int

@app.post("/users/")
def create_user(user: User = None):
    return {"username": user.username, "age": user.age}

medium

A. Request body parameter cannot have a default value None

B. Missing async keyword in endpoint function

C. User class must inherit from object, not BaseModel

D. Return statement must be inside an async function

Solution

1. Step 1: Check request body parameter declaration

   In FastAPI, request body parameters cannot have a default value of None because the body is required by default.

2. Step 2: Review other options

   Async is optional for FastAPI endpoints; BaseModel inheritance is correct; return works in sync functions.

3. Final Answer:

   Request body parameter cannot have a default value None -> Option A

4. Quick Check:

   Request body params must not default to None [OK]

Hint: Request body params must be required unless explicitly optional [OK]

Common Mistakes:

• Adding default None to request body param
• Thinking async is mandatory
• Misunderstanding BaseModel inheritance

5. You want to declare a request body in FastAPI that accepts an optional field description which can be missing or null. How should you declare the Pydantic model to handle this correctly?

hard

A. from pydantic import BaseModel
from typing import Optional

class Item(BaseModel):
name: str
description: Optional[str] = None

B. from pydantic import BaseModel

class Item(BaseModel):
name: str
description: str

C. from pydantic import BaseModel
from typing import Union

class Item(BaseModel):
name: str
description: Union[str, None] = None

D. from pydantic import BaseModel

class Item(BaseModel):
name: str
description: None

Solution

1. Step 1: Understand optional fields in Pydantic

   To allow a field to be optional or null, use Optional[type] with a default value None.

2. Step 2: Analyze each option

   from pydantic import BaseModel from typing import Optional class Item(BaseModel): name: str description: Optional[str] = None correctly uses Optional[str] with default None; from pydantic import BaseModel class Item(BaseModel): name: str description: str requires description always; from pydantic import BaseModel from typing import Union class Item(BaseModel): name: str description: Union[str, None] = None uses Union[str, None] with default None; from pydantic import BaseModel class Item(BaseModel): name: str description: None sets description to None type which is invalid.

3. Final Answer:

   Use Optional[str] with default None for optional nullable field -> Option A

4. Quick Check:

   Optional field = Optional[type] + default None [OK]

Hint: Use Optional[type] and default None for optional fields [OK]

Common Mistakes:

• Forgetting to set default None for optional fields
• Using plain type without Optional for nullable fields
• Assigning None as a type instead of a value