File size limits in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a file larger than the limit is uploaded?

Consider a Flask app with this setting:
app.config['MAX_CONTENT_LENGTH'] = 1024 * 1024
This limits uploads to 1MB.
What happens if a user tries to upload a 2MB file?

A Flask accepts the file but truncates it to 1MB before saving.

B Flask raises a RequestEntityTooLarge exception and returns a 413 error automatically.

C Flask silently ignores the file and processes the request as if no file was sent.

D Flask crashes and stops the server due to memory overflow.

💡 Hint

Think about how Flask handles requests exceeding the max content length.

Flask automatically raises a RequestEntityTooLarge exception when the uploaded file size exceeds MAX_CONTENT_LENGTH. This results in a 413 HTTP error response.

📝 Syntax

intermediate

Which code correctly sets a 5MB upload limit in Flask?

You want to limit file uploads to 5 megabytes in your Flask app.
Which code snippet correctly sets this limit?

A app.config['MAX_CONTENT_LENGTH'] = 5 ** 1024 ** 1024

B app.config['MAX_CONTENT_LENGTH'] = 5 * 1000 * 1000

C app.config['MAX_CONTENT_LENGTH'] = '5MB'

D app.config['MAX_CONTENT_LENGTH'] = 5 * 1024 * 1024

💡 Hint

Remember that the limit is in bytes and 1MB = 1024 * 1024 bytes.

The MAX_CONTENT_LENGTH config expects an integer number of bytes. 5MB is 5 times 1024 * 1024 bytes.

🔧 Debug

advanced

Why does this Flask app not block large uploads?

Given this Flask app snippet:

app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024

@app.route('/upload', methods=['POST'])
def upload():
    file = request.files['file']
    file.save('/tmp/' + file.filename)
    return 'File saved'

Users report uploading files larger than 2MB without errors.
What is the most likely reason?

A The MAX_CONTENT_LENGTH config is set correctly but the server is behind a proxy that allows larger uploads.

B The app does not handle the RequestEntityTooLarge exception, so uploads proceed anyway.

C The client is not sending the Content-Length header, so Flask cannot enforce the limit.

D The MAX_CONTENT_LENGTH setting must be set before creating the Flask app instance.

💡 Hint

Consider how proxies or web servers might affect upload limits.

Flask enforces MAX_CONTENT_LENGTH on the request size it receives. If a proxy or web server in front allows larger uploads, Flask may never see the limit exceeded.

❓ state_output

advanced

What is the value of request.content_length for a 3MB upload?

In a Flask route handling a POST file upload, the user uploads a file exactly 3 megabytes in size.
What will request.content_length contain?

A None, because content_length is only set for GET requests

B 3000000 (which is 3 * 1000 * 1000 bytes)

C 3145728 (which is 3 * 1024 * 1024 bytes)

D Raises an AttributeError because content_length is not available

💡 Hint

Content length is the size in bytes of the request body.

request.content_length returns the size of the request body in bytes, which for 3MB is 3 * 1024 * 1024 = 3145728 bytes.

🧠 Conceptual

expert

How to customize the error response for large file uploads in Flask?

You want your Flask app to return a custom JSON message when a user uploads a file larger than the limit.
Which approach correctly achieves this?

A Use an errorhandler for RequestEntityTooLarge to return a JSON response with status 413.

B Catch the exception inside the route function and return JSON manually.

C Override the MAX_CONTENT_LENGTH setting with a function that returns JSON on error.

D Set a custom response in app.config['MAX_CONTENT_LENGTH_RESPONSE'] with the JSON message.

💡 Hint

Flask allows custom error handlers for exceptions.

Flask lets you register an error handler for RequestEntityTooLarge that can return any response, including JSON with a 413 status.

Practice

1. What does setting MAX_CONTENT_LENGTH in a Flask app do?

easy

A. Sets the maximum number of files a user can upload.

B. Limits the maximum size of incoming request data, like file uploads.

C. Defines the maximum number of users allowed to connect.

D. Controls the maximum time a request can take to process.

Solution

1. Step 1: Understand the role of MAX_CONTENT_LENGTH

   This setting defines the maximum size in bytes for incoming request data, such as file uploads.

2. Step 2: Identify what it limits

   It limits the size of the request body, preventing large uploads that could harm the app.

3. Final Answer:

   Limits the maximum size of incoming request data, like file uploads. -> Option B

4. Quick Check:

   MAX_CONTENT_LENGTH limits upload size [OK]

Hint: MAX_CONTENT_LENGTH sets max upload size in bytes [OK]

Common Mistakes:

• Confusing size limit with number of files
• Thinking it limits request time
• Assuming it controls user connections

2. Which of the following is the correct way to set a 2MB file size limit in Flask?

easy

A. app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024

B. app.MAX_CONTENT_LENGTH = 2 * 1024 * 1024

C. app.config.MAX_CONTENT_LENGTH = 2 * 1024 * 1024

D. app.set_config('MAX_CONTENT_LENGTH', 2 * 1024 * 1024)

Solution

1. Step 1: Recall Flask config syntax

   Flask config values are set using app.config dictionary syntax.

2. Step 2: Check each option

   app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024 uses app.config['MAX_CONTENT_LENGTH'] correctly. Others use invalid syntax.

3. Final Answer:

   app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024 -> Option A

4. Quick Check:

   Use app.config['KEY'] = value [OK]

Hint: Use app.config['KEY'] to set Flask config [OK]

Common Mistakes:

• Using dot notation instead of dictionary
• Calling non-existent set_config method
• Assigning config directly on app object

3. Given this Flask app code snippet, what happens if a user uploads a 3MB file?

app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024

@app.route('/upload', methods=['POST'])
def upload():
    file = request.files['file']
    return 'File uploaded!'

medium

A. Flask automatically returns a 413 error and blocks the upload.

B. The upload succeeds and returns 'File uploaded!'

C. The app crashes with a runtime error.

D. The file is accepted but truncated to 2MB.

Solution

1. Step 1: Understand MAX_CONTENT_LENGTH effect on uploads

   Flask rejects requests exceeding this size with a 413 error automatically.

2. Step 2: Analyze the 3MB upload against 2MB limit

   3MB is larger than 2MB limit, so Flask blocks the request before reaching the route.

3. Final Answer:

   Flask automatically returns a 413 error and blocks the upload. -> Option A

4. Quick Check:

   Upload > MAX_CONTENT_LENGTH causes 413 error [OK]

Hint: Uploads over limit get 413 error automatically [OK]

Common Mistakes:

• Assuming upload succeeds anyway
• Thinking app crashes instead of 413 error
• Believing file is truncated silently

4. Identify the error in this Flask code that tries to limit upload size:

app.config['MAX_CONTENT_LENGTH'] = 5 * 1024 * 1024

@app.route('/upload', methods=['POST'])
def upload():
    if request.content_length > app.config['MAX_CONTENT_LENGTH']:
        return 'File too large', 413
    file = request.files['file']
    return 'Upload successful'

medium

A. The route should allow GET method to upload files.

B. The content_length attribute does not exist on request.

C. The manual size check is unnecessary; Flask blocks large uploads automatically.

D. The MAX_CONTENT_LENGTH value must be set in bytes, not calculated.

Solution

1. Step 1: Recall Flask's built-in upload size handling

   Flask automatically returns a 413 error if upload exceeds MAX_CONTENT_LENGTH.

2. Step 2: Analyze the manual check in code

   The manual check duplicates Flask's behavior and is redundant.

3. Final Answer:

   The manual size check is unnecessary; Flask blocks large uploads automatically. -> Option C

4. Quick Check:

   Flask auto-blocks large uploads, no manual check needed [OK]

Hint: Flask auto-blocks large uploads; no manual check needed [OK]

Common Mistakes:

• Thinking content_length is missing
• Believing GET method is required for uploads
• Misunderstanding byte calculation for MAX_CONTENT_LENGTH

5. You want to allow file uploads up to 10MB but also want to show a custom error page instead of Flask's default 413 error. Which approach is best?

hard

A. Set MAX_CONTENT_LENGTH to 10MB and catch exceptions in the route to show custom error.

B. Remove MAX_CONTENT_LENGTH and manually check file size in the route.

C. Set MAX_CONTENT_LENGTH to 20MB and reject files over 10MB manually.

D. Set MAX_CONTENT_LENGTH to 10MB and add an error handler for 413 to show a custom page.

Solution

1. Step 1: Set MAX_CONTENT_LENGTH to desired limit

   Setting it to 10MB ensures Flask blocks uploads larger than this automatically.

2. Step 2: Add a Flask error handler for 413 errors

   Define a custom error handler to display a friendly message instead of default error.

3. Step 3: Avoid manual size checks or mismatched limits

   Manual checks or mismatched limits complicate logic and risk errors.

4. Final Answer:

   Set MAX_CONTENT_LENGTH to 10MB and add an error handler for 413 to show a custom page. -> Option D

5. Quick Check:

   Use MAX_CONTENT_LENGTH + 413 error handler for custom message [OK]

Hint: Use MAX_CONTENT_LENGTH + 413 error handler for custom message [OK]

Common Mistakes:

• Removing MAX_CONTENT_LENGTH and checking manually
• Setting limit higher than needed and manual rejection
• Catching exceptions instead of error handlers