File size limits in Flask - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of setting file size limits in Flask?

Setting file size limits in Flask helps prevent users from uploading files that are too large, which can protect the server from running out of memory or disk space and improve security.

beginner

How do you set a maximum file size limit in a Flask application?

You set the maximum file size limit by configuring the Flask app with the key MAX_CONTENT_LENGTH. For example, app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 limits uploads to 16 megabytes.

intermediate

What happens if a user tries to upload a file larger than the limit set by MAX_CONTENT_LENGTH?

Flask automatically stops the upload and raises a RequestEntityTooLarge exception, which you can catch to show a friendly error message to the user.

intermediate

How can you handle the error when a file is too large in Flask?

You can use Flask's error handler decorator for <code>RequestEntityTooLarge</code> to catch the error and return a custom message or page. For example:<br><pre>from werkzeug.exceptions import RequestEntityTooLarge

@app.errorhandler(RequestEntityTooLarge)
def handle_file_too_large(e):
    return 'File is too large', 413</pre>

beginner

Why is it important to set file size limits on the server side even if the client limits file size?

Client-side limits can be bypassed by users or malicious actors. Server-side limits ensure the server is protected regardless of client behavior, making your app more secure and reliable.

Which Flask configuration key sets the maximum allowed size for uploaded files?

A MAX_FILE_SIZE

B MAX_CONTENT_LENGTH

C UPLOAD_LIMIT

D FILE_SIZE_MAX

The correct key is MAX_CONTENT_LENGTH to limit the size of incoming request data including file uploads.

What exception does Flask raise when a file exceeds the size limit?

A RequestEntityTooLarge

B FileSizeExceeded

C UploadLimitError

D FileTooBigException

Flask raises RequestEntityTooLarge when the uploaded file is bigger than MAX_CONTENT_LENGTH.

If you want to limit uploads to 5 megabytes, what value should you set for MAX_CONTENT_LENGTH?

A 5000

B 5 * 1000 * 1000

C 5 * 1024 * 1024

D 5

MAX_CONTENT_LENGTH expects bytes, so 5 megabytes is 5 * 1024 * 1024 bytes.

Why should you handle the RequestEntityTooLarge error in your Flask app?

A To restart the server

B To increase the file size limit automatically

C To allow the upload anyway

D To show a friendly message instead of a default error page

Handling the error lets you inform users nicely that their file is too big.

Which of these is NOT a reason to set file size limits on the server?

A Make uploads faster

B Improve security

C Prevent server overload

D Avoid running out of disk space

File size limits protect resources and security but do not directly make uploads faster.

Explain how to set and handle file size limits in a Flask application.

Think about configuration and error handling steps.

Why is server-side file size limiting important even if the client limits file size?

Consider trust and control between client and server.

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