File validation (size, type) in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the FastAPI class.

FastAPI

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

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

AFastAPI

BFile

CRequest

DUploadFile

Attempts:

3 left

💡 Hint

Common Mistakes

Importing UploadFile instead of FastAPI

Using Request instead of FastAPI

The FastAPI class is imported to create the app instance.

2fill in blank

medium

Complete the code to accept a file upload in the endpoint.

FastAPI

@app.post('/upload')
async def upload_file(file: [1]):
    return {'filename': file.filename}

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

Astr

BUploadFile

CFile

Dbytes

Attempts:

3 left

💡 Hint

Common Mistakes

Using str or bytes instead of UploadFile

Using File as a type instead of UploadFile

UploadFile is used to receive uploaded files in FastAPI endpoints.

3fill in blank

hard

Fix the error in the code to limit file size to 1MB.

FastAPI

from fastapi import File, UploadFile

@app.post('/upload')
async def upload_file(file: UploadFile = File(..., [1]=1048576)):
    return {'filename': file.filename}

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

Amax_file_size

Bmax_length

Cmax_size

Dmax_bytes

Attempts:

3 left

💡 Hint

Common Mistakes

Using max_length or max_file_size which are invalid

Using max_bytes which is not recognized

The correct parameter to limit file size in File() is max_size.

4fill in blank

hard

Fill both blanks to check the uploaded file's content type and reject if not an image.

FastAPI

from fastapi import HTTPException

@app.post('/upload')
async def upload_file(file: UploadFile):
    if file.content_type != [1]:
        raise HTTPException(status_code=400, detail=[2])
    return {'filename': file.filename}

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

A'image/png'

B'Invalid file type'

C'application/pdf'

D'File type not allowed'

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for wrong content type like 'application/pdf'

Using incorrect error messages

We check if the file's content_type is 'image/png' and raise an error with message 'Invalid file type' if not.

5fill in blank

hard

Fill all three blanks to create a file validation that accepts only JPEG images under 2MB.

FastAPI

from fastapi import File, UploadFile, HTTPException

@app.post('/upload')
async def upload_file(file: UploadFile = File(..., [1]=2097152)):
    if file.content_type != [2]:
        raise HTTPException(status_code=400, detail=[3])
    return {'filename': file.filename}

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

Amax_size

B'image/jpeg'

C'Only JPEG images under 2MB are allowed'

D'image/png'

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong max_size parameter

Checking for 'image/png' instead of 'image/jpeg'

Incorrect error messages

max_size limits file size to 2MB, content_type is checked for 'image/jpeg', and error message explains the restriction.

Practice

1. What is the main purpose of validating file size and type in a FastAPI upload endpoint?

easy

A. To ensure only allowed file types and sizes are accepted for security and performance

B. To automatically convert files to a specific format

C. To speed up the file upload process by skipping checks

D. To store files directly in the database without validation

Solution

1. Step 1: Understand file validation purpose

   File validation ensures that only files meeting size and type rules are accepted.

2. Step 2: Recognize security and performance reasons

   Validating prevents harmful files and avoids server overload from large files.

3. Final Answer:

   To ensure only allowed file types and sizes are accepted for security and performance -> Option A

4. Quick Check:

   File validation = security and performance [OK]

Hint: File validation protects server and users from bad files [OK]

Common Mistakes:

• Thinking validation changes file content
• Assuming validation speeds upload without checks
• Ignoring security risks of unvalidated files

2. Which of the following is the correct way to declare a file upload parameter in a FastAPI endpoint to accept files asynchronously?

easy

A. def upload(file: UploadFile = File(...)):

B. def upload(file: str):

C. def upload(file: bytes):

D. def upload(file: int):

Solution

1. Step 1: Identify FastAPI file upload type

   FastAPI uses UploadFile with File(...) to handle async file uploads.

2. Step 2: Check parameter types

   Only UploadFile supports async file handling, bytes or str do not.

3. Final Answer:

   def upload(file: UploadFile = File(...)): -> Option A

4. Quick Check:

   UploadFile + File(...) = async file upload [OK]

Hint: Use UploadFile with File(...) for async uploads [OK]

Common Mistakes:

• Using bytes or str instead of UploadFile
• Missing File(...) dependency
• Using int type for file parameter

3. Given this FastAPI code snippet, what will happen if a user uploads a 5MB PNG file?

from fastapi import FastAPI, File, UploadFile, HTTPException

app = FastAPI()

@app.post('/upload')
async def upload(file: UploadFile = File(...)):
    if file.content_type not in ['image/png', 'image/jpeg']:
        raise HTTPException(status_code=400, detail='Invalid file type')
    contents = await file.read()
    if len(contents) > 2_000_000:
        raise HTTPException(status_code=400, detail='File too large')
    return {'filename': file.filename, 'size': len(contents)}

medium

A. Returns filename and size successfully

B. Raises HTTPException with 'File too large'

C. Raises HTTPException with 'Invalid file type'

D. Raises a syntax error

Solution

1. Step 1: Check file type condition

   The file is PNG, which is allowed, so no error here.

2. Step 2: Check file size condition

   The file size is 5MB (5,000,000 bytes), exceeding 2,000,000 limit, so it raises 'File too large'.

3. Final Answer:

   Raises HTTPException with 'File too large' -> Option B

4. Quick Check:

   File size > 2MB = 'File too large' error [OK]

Hint: Check size limit after reading file contents [OK]

Common Mistakes:

• Confusing file type error with size error
• Not reading file contents before size check
• Assuming no error for large files

4. Identify the error in this FastAPI file validation code:

from fastapi import FastAPI, File, UploadFile, HTTPException

app = FastAPI()

@app.post('/upload')
async def upload(file: UploadFile = File(...)):
    if file.content_type != 'image/png' or file.content_type != 'image/jpeg':
        raise HTTPException(status_code=400, detail='Invalid file type')
    contents = await file.read()
    if len(contents) > 1_000_000:
        raise HTTPException(status_code=400, detail='File too large')
    return {'filename': file.filename}

medium

A. The file size check uses wrong comparison operator

B. UploadFile should not be used with File(...)

C. The file type condition always raises error due to incorrect logic

D. Missing await keyword before file.read()

Solution

1. Step 1: Analyze file type condition logic

   The condition uses 'or' with != checks, so it is always true (a file can't be both types).

2. Step 2: Understand consequence of condition

   This causes the error to always raise, rejecting all files incorrectly.

3. Final Answer:

   The file type condition always raises error due to incorrect logic -> Option C

4. Quick Check:

   Incorrect 'or' with != always true = logic error [OK]

Hint: Use 'and' when checking multiple 'not equals' conditions [OK]

Common Mistakes:

• Using 'or' instead of 'and' in file type checks
• Forgetting to await file.read()
• Misunderstanding UploadFile usage

5. You want to create a FastAPI endpoint that accepts only PDF files smaller than 3MB. Which code snippet correctly implements this validation?

hard

A. async def upload(file: UploadFile = File(...)):
contents = await file.read()
if file.content_type == 'application/pdf' or len(contents) < 3_000_000:
return {'filename': file.filename}
raise HTTPException(400, 'Invalid file')

B. async def upload(file: UploadFile = File(...)):
if file.content_type == 'application/pdf' or len(await file.read()) < 3_000_000:
return {'filename': file.filename}
raise HTTPException(400, 'Invalid file')

C. async def upload(file: UploadFile = File(...)):
if file.content_type == 'application/pdf' or len(await file.read()) > 3_000_000:
raise HTTPException(400, 'Invalid file')
return {'filename': file.filename}

D. async def upload(file: UploadFile = File(...)):
if file.content_type != 'application/pdf':
raise HTTPException(400, 'Invalid type')
contents = await file.read()
if len(contents) > 3_000_000:
raise HTTPException(400, 'Too large')
return {'filename': file.filename}

Solution

1. Step 1: Check file type validation

   Correct snippet uses != 'application/pdf' to reject invalid types before reading contents. Distractors misuse operators like 'or' instead of 'and' or check type after reading.

2. Step 2: Check file size validation

   After type approval, read contents once and raise if len > 3_000_000. Combined conditions fail due to incorrect logic.

3. Final Answer:

   Separate type (!=) and size (> 3MB) checks -> Option D

4. Quick Check:

   != type reject + read then > size reject [OK]

Hint: Check type and size separately with correct logic [OK]

Common Mistakes:

• Using 'or' instead of 'and' in conditions
• Reading file multiple times causing empty content
• Incorrect comparison operators in conditions