Route decorator syntax in FastAPI - Step-by-Step Execution

Concept Flow - Route decorator syntax

Define function

↓

Apply @app.route decorator

↓

Register route with path and method

↓

Wait for HTTP request

↓

If request matches path and method

↓

Call decorated function

↓

Return response to client

This flow shows how a function is decorated with a route, registered, and called when a matching HTTP request arrives.

Execution Sample

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/hello")
async def say_hello():
    return {"message": "Hello!"}

Defines a GET route at /hello that returns a JSON greeting message.

Execution Table

Step	Action	Evaluation	Result
1	Define async function say_hello	Function created	Function object stored
2	Apply @app.get("/hello") decorator	Register route '/hello' with GET method	Route added to app's routing table
3	Start FastAPI server	Server listens for requests	Ready to accept HTTP requests
4	Receive GET request at /hello	Match request path and method	Route matched, call say_hello()
5	Execute say_hello()	Return {'message': 'Hello!'}	Response JSON generated
6	Send response to client	HTTP 200 with JSON body	Client receives greeting message

💡 Execution stops after response sent to client.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
say_hello	undefined	function object	function object	function object	function object
app.routes	empty list	contains route '/hello' GET	contains route '/hello' GET	contains route '/hello' GET	contains route '/hello' GET
request	none	none	GET /hello request object	GET /hello request object	none
response	none	none	none	{'message': 'Hello!'}	sent to client

Key Moments - 3 Insights

Why do we use @app.get("/hello") above the function?

The decorator registers the function as the handler for GET requests to '/hello'. Without it, the function won't be called on requests. See execution_table step 2.

What happens if a request comes to a different path?

FastAPI checks registered routes and finds no match, so it returns a 404 error. This is because only '/hello' is registered here (execution_table step 4).

Why is the function defined as async?

FastAPI supports async functions to handle requests efficiently. The async keyword allows the server to handle other tasks while waiting for this function to complete (execution_table step 5).

Visual Quiz - 3 Questions

Look at the execution table, what is the state of app.routes after step 2?

A It contains the route '/hello' with GET method

B It is still empty

C It contains the route '/hello' with POST method

D It contains multiple routes

💡 Hint

Check the 'app.routes' variable in variable_tracker after step 2.

At which step does FastAPI call the decorated function to handle the request?

A Step 2

B Step 5

C Step 4

D Step 6

💡 Hint

Look at execution_table where the function execution and response generation happen.

If we change @app.get to @app.post, what changes in the execution?

A Both GET and POST requests will call the function

B GET requests to '/hello' will still call the function

C POST requests to '/hello' will call the function instead of GET

D No requests will call the function

💡 Hint

Consider how the route method affects which HTTP requests trigger the function (see execution_table step 2 and 4).

Concept Snapshot

Route decorator syntax in FastAPI:
- Use @app.get('/path') or @app.post('/path') above async function
- Registers function as handler for HTTP method and path
- When matching request arrives, FastAPI calls function
- Function returns response (usually JSON)
- Async functions improve server efficiency

Full Transcript

In FastAPI, you define a function and decorate it with @app.get or @app.post to register it as a route handler. The decorator tells FastAPI which URL path and HTTP method the function should respond to. When the server runs and receives a request, it checks if the path and method match any registered routes. If yes, it calls the decorated function and sends back its return value as the response. This example shows a GET route at '/hello' that returns a JSON greeting. The function is async to allow efficient handling of requests. The execution table traces defining the function, applying the decorator, receiving a request, calling the function, and sending the response. Variables like the function object, app routes, request, and response change state during these steps. Common confusions include why decorators are needed, what happens on unmatched paths, and why async is used. The visual quiz tests understanding of route registration, function calling, and HTTP method effects.

Practice

1. What does the @app.get("/items") decorator do in FastAPI?

easy

A. It deletes the route for '/items' from the app.

B. It creates a route that responds to POST requests at the URL path '/items'.

C. It defines a function that runs only when the server starts.

D. It creates a route that responds to GET requests at the URL path '/items'.

Solution

1. Step 1: Understand the decorator purpose

   The @app.get() decorator in FastAPI is used to create a route that listens for HTTP GET requests.

2. Step 2: Match the URL path

   The string inside the parentheses, here '/items', specifies the URL path this route will respond to.

3. Final Answer:

   It creates a route that responds to GET requests at the URL path '/items'. -> Option D

4. Quick Check:

   @app.get() = GET route [OK]

Hint: GET decorator means respond to GET requests [OK]

Common Mistakes:

• Confusing @app.get with @app.post
• Thinking it runs on server start
• Assuming it deletes routes

2. Which of the following is the correct syntax to create a POST route for path '/submit' in FastAPI?

easy

A. @app.post('/submit')

B. @app.get('/submit')

C. @app.route('/submit', method='POST')

D. @app.post('/submit', method='GET')

Solution

1. Step 1: Identify the correct decorator for POST

   FastAPI uses @app.post() to define routes that handle POST requests.

2. Step 2: Check the path argument

   The path '/submit' should be passed as a string inside the parentheses.

3. Final Answer:

   @app.post('/submit') -> Option A

4. Quick Check:

   POST route syntax = @app.post(path) [OK]

Hint: Use @app.post() for POST routes with path string [OK]

Common Mistakes:

• Using @app.get for POST routes
• Trying to pass method='POST' inside @app.post
• Using @app.route which is not FastAPI syntax

3. What will be the output when accessing the URL '/hello' if the following FastAPI code is used?

from fastapi import FastAPI
app = FastAPI()

@app.get('/hello')
def say_hello():
    return {"message": "Hello, FastAPI!"}

medium

A. Hello, FastAPI!

B. 404 Not Found error

C. {"message": "Hello, FastAPI!"}

D. 500 Internal Server Error

Solution

1. Step 1: Identify the route and method

   The route '/hello' is defined with @app.get('/hello'), so GET requests to '/hello' will call say_hello().

2. Step 2: Check the function return value

   The function returns a dictionary with key 'message' and value 'Hello, FastAPI!'. FastAPI automatically converts this to JSON.

3. Final Answer:

   "{\"message\": \"Hello, FastAPI!\"}" -> Option C

4. Quick Check:

   Route returns dict = JSON response [OK]

Hint: Return dict in route becomes JSON response [OK]

Common Mistakes:

• Expecting plain string instead of JSON
• Assuming 404 error without route
• Confusing error codes with correct response

4. Identify the error in this FastAPI route definition:

from fastapi import FastAPI
app = FastAPI()

@app.get('/data')
def get_data():
print("Fetching data")
    return {"data": 123}

medium

A. Indentation error in the function body.

B. Missing parentheses in @app.get decorator.

C. Route path should not start with a slash.

D. Function name cannot be get_data.

Solution

1. Step 1: Check function body indentation

   Python requires the function body to be indented. Here, print("Fetching data") is not indented properly.

2. Step 2: Verify decorator and path syntax

   The decorator @app.get('/data') is correct, and the path starting with '/' is valid in FastAPI.

3. Final Answer:

   Indentation error in the function body. -> Option A

4. Quick Check:

   Python functions need indented bodies [OK]

Hint: Check indentation inside function after decorator [OK]

Common Mistakes:

• Ignoring Python indentation rules
• Thinking path cannot start with '/'
• Assuming decorator needs no parentheses

5. You want to create a FastAPI route that handles both GET and POST requests on the path '/process'. Which is the correct way to write the decorators?

hard

A. @app.get_post('/process')

B. @app.get('/process')
@app.post('/process')

C. @app.route('/process', methods=['GET', 'POST'])

D. @app.get('/process', methods=['GET', 'POST'])

Solution

1. Step 1: Understand FastAPI route decorators

   FastAPI does not have a combined decorator for multiple methods. Instead, you add multiple decorators for each method on the same function.

2. Step 2: Check each option's validity

   @app.get('/process') @app.post('/process') uses two decorators @app.get and @app.post on the same function, which is correct. @app.route('/process', methods=['GET', 'POST']) uses Flask-style syntax which is invalid in FastAPI. Options A and D use non-existent decorators or invalid parameters.

3. Final Answer:

   @app.get('/process') @app.post('/process') -> Option B

4. Quick Check:

   Multiple decorators for multiple methods [OK]

Hint: Use multiple decorators for multiple HTTP methods [OK]

Common Mistakes:

• Trying to use Flask-style @app.route
• Assuming combined decorator exists
• Passing methods param to @app.get