Error handler decorators in Flask - Step-by-Step Execution

Concept Flow - Error handler decorators

Define Flask app

↓

Create route

↓

Raise error in route

↓

Error occurs

↓

Error handler decorator catches error

↓

Return custom error response

↓

Client receives error message

This flow shows how Flask routes can raise errors, which are then caught by error handler decorators to return custom responses.

Execution Sample

Flask

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/error')
def error_route():
    raise ValueError('Oops!')

@app.errorhandler(ValueError)
def handle_value_error(e):
    return jsonify({'error': str(e)}), 400

This Flask app defines a route that raises a ValueError, and an error handler decorator that catches it and returns a JSON error message with status 400.

Execution Table

Step	Action	Evaluation	Result
1	Client requests /error route	Route function error_route called	ValueError raised with message 'Oops!'
2	Error raised	Flask looks for error handler for ValueError	handle_value_error function found
3	handle_value_error called with error	Returns JSON {'error': 'Oops!'} and status 400	Response sent to client
4	Client receives response	Response contains JSON error message and HTTP 400 status	Error handled gracefully

💡 Error is caught by the error handler decorator, so Flask returns a custom error response instead of crashing.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
e (error)	None	None	ValueError('Oops!')	ValueError('Oops!')	Handled in error handler

Key Moments - 2 Insights

Why doesn't the app crash when ValueError is raised in the route?

Because the error handler decorator @app.errorhandler(ValueError) catches the error and returns a custom response instead of letting the error propagate. See execution_table step 2 and 3.

How does Flask know which function handles the error?

Flask matches the error type raised (ValueError) with the function decorated by @app.errorhandler(ValueError). This is shown in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the error message passed to the error handler at step 3?

A 'ValueError'

B 'Oops!'

C 'Error occurred'

D 'Unhandled exception'

💡 Hint

Check the 'Evaluation' column at step 3 in the execution_table.

At which step does Flask find the error handler function for the raised error?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column in the execution_table where Flask searches for the handler.

If the error handler decorator was missing, what would happen at step 3?

A The app would silently ignore the error

B Flask would return the JSON error message anyway

C Flask would return a default 500 Internal Server Error

D The client would receive a 200 OK response

💡 Hint

Think about what Flask does when no error handler matches an exception.

Concept Snapshot

Flask error handler decorators catch exceptions raised in routes.
Use @app.errorhandler(ErrorType) to define a handler function.
The handler receives the error and returns a custom response.
This prevents app crashes and improves user experience.
Handlers match error types raised during request processing.

Full Transcript

In Flask, when a route raises an error like ValueError, the app can crash if not handled. Using error handler decorators, you tell Flask how to catch specific errors and respond with custom messages. The flow starts with a client request to a route that raises an error. Flask detects the error and looks for a matching error handler decorated with @app.errorhandler for that error type. When found, Flask calls the handler function, passing the error object. The handler returns a JSON response with an error message and HTTP status code. This way, the client receives a clear error message instead of a server crash. Variables like the error object 'e' hold the error details during handling. This method improves app stability and user feedback.

Practice

1. What is the main purpose of using @app.errorhandler decorator in Flask?

easy

A. To catch specific errors and return custom responses

B. To define routes for the application

C. To start the Flask server

D. To connect to a database

Solution

1. Step 1: Understand the role of error handlers

   Error handlers catch errors like 404 or 500 and let you respond with custom messages.

2. Step 2: Recognize the decorator's purpose

   @app.errorhandler is used to register functions that handle specific errors gracefully.

3. Final Answer:

   To catch specific errors and return custom responses -> Option A

4. Quick Check:

   Error handler = Custom error response [OK]

Hint: Error handlers catch errors and customize replies [OK]

Common Mistakes:

• Confusing errorhandler with route decorator
• Thinking it starts the server
• Assuming it manages database connections

2. Which of the following is the correct syntax to handle 404 errors in Flask?

easy

A. @app.errorhandler('404')
def handle_404(error):
return 'Not Found', 404

B. @app.errorhandler(404)
def handle_404(error):
return 'Not Found', 404

C. @app.route(404)
def handle_404():
return 'Not Found'

D. @app.errorhandler(HTTP_404)
def handle_404(error):
return 'Not Found', 404

Solution

1. Step 1: Identify correct decorator usage

   The @app.errorhandler decorator takes an integer error code like 404, not a string or undefined constant.

2. Step 2: Check function signature and return

   The handler function must accept an error argument and return a response with status code.

3. Final Answer:

   @app.errorhandler(404) def handle_404(error): return 'Not Found', 404 -> Option B

4. Quick Check:

   Use integer error code with errorhandler [OK]

Hint: Use integer error code, not string or constants [OK]

Common Mistakes:

• Using @app.route instead of @app.errorhandler
• Passing error code as string '404'
• Using undefined constants like HTTP_404

3. What will be the output when a 500 error occurs with this code?

@app.errorhandler(500)
def internal_error(error):
    return 'Server Error Occurred', 500

@app.route('/')
def index():
    raise Exception('Oops')

medium

A. Server Error Occurred with status code 500

B. Exception traceback shown in browser

C. 404 Not Found error page

D. Empty response with status code 200

Solution

1. Step 1: Understand error raising in route

   The index route raises a generic Exception, which triggers a 500 Internal Server Error.

2. Step 2: Check error handler for 500

   The @app.errorhandler(500) catches this error and returns the custom message with status 500.

3. Final Answer:

   Server Error Occurred with status code 500 -> Option A

4. Quick Check:

   500 error triggers custom handler message [OK]

Hint: Exception triggers 500 error handler message [OK]

Common Mistakes:

• Expecting default Flask error page instead of custom
• Confusing 404 with 500 error
• Assuming no response is returned

4. Identify the error in this Flask error handler code:

@app.errorhandler(403)
def forbidden():
    return 'Forbidden Access', 403

medium

A. Incorrect error code used in decorator

B. Return statement missing status code

C. Missing error parameter in handler function

D. Decorator should be @app.route instead

Solution

1. Step 1: Check function signature for error handlers

   Error handler functions must accept one parameter for the error object.

2. Step 2: Identify missing parameter

   The function forbidden has no parameters, so Flask will raise a TypeError.

3. Final Answer:

   Missing error parameter in handler function -> Option C

4. Quick Check:

   Error handler needs error argument [OK]

Hint: Error handler functions must accept error argument [OK]

Common Mistakes:

• Omitting the error parameter in handler function
• Using @app.route instead of @app.errorhandler
• Forgetting to return status code with response

5. You want to handle both 404 and 405 errors with the same function in Flask. Which code correctly achieves this?

hard

A. @app.errorhandler(404, 405)
def handle_errors(error):
return f'Error {error.code} occurred', error.code

B. @app.errorhandler([404, 405])
def handle_errors(error):
return f'Error {error.code} occurred', error.code

C. @app.errorhandler(404 or 405)
def handle_errors(error):
return f'Error {error.code} occurred', error.code

D. @app.errorhandler(404)
@app.errorhandler(405)
def handle_errors(error):
return f'Error {error.code} occurred', error.code

Solution

1. Step 1: Understand Flask errorhandler decorator usage

   Flask does not accept a list or multiple codes in one decorator call; you must stack decorators for multiple errors.

2. Step 2: Identify correct stacking syntax

   Using two @app.errorhandler decorators stacked on the same function handles both errors with one function.

3. Final Answer:

   @app.errorhandler(404) @app.errorhandler(405) def handle_errors(error): return f'Error {error.code} occurred', error.code -> Option D

4. Quick Check:

   Stack decorators for multiple error codes [OK]

Hint: Stack multiple @app.errorhandler decorators for several errors [OK]

Common Mistakes:

• Passing list or multiple codes in one decorator
• Using logical OR inside decorator argument
• Trying to pass multiple arguments to one decorator