Sending and receiving messages in FastAPI - Step-by-Step Execution

Concept Flow - Sending and receiving messages

Client sends HTTP request

↓

FastAPI receives request

↓

Process request in endpoint function

↓

Send response message back to client

↓

Client receives response

This flow shows how a client sends a message (HTTP request) to FastAPI, which processes it and sends back a response message.

Execution Sample

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.post('/message')
async def receive_message(msg: dict):
    return {'received': msg}

This code defines a FastAPI endpoint that receives a message as JSON and returns it back in the response.

Execution Table

Step	Action	Input	Processing	Output
1	Client sends POST /message	{'text': 'Hello'}	FastAPI receives request	Request received
2	FastAPI calls receive_message	{'text': 'Hello'}	Function receives msg dict	Prepare response {'received': {'text': 'Hello'}}
3	FastAPI sends response	Response dict	Serialize to JSON	HTTP 200 with JSON body
4	Client receives response	HTTP 200 with JSON	Parse JSON	{'received': {'text': 'Hello'}}

💡 Request-response cycle completes after client receives the response.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
msg	None	None	{'text': 'Hello'}	{'text': 'Hello'}	{'text': 'Hello'}
response	None	None	None	{'received': {'text': 'Hello'}}	{'received': {'text': 'Hello'}}

Key Moments - 2 Insights

How does FastAPI know to convert the incoming JSON to a Python dict?

FastAPI automatically parses JSON request bodies into Python data types based on the function parameter type (here, dict). See Step 2 in execution_table where msg is a dict.

Why does the response include the original message inside 'received'?

The endpoint returns a dict with key 'received' holding the msg dict. This is shown in Step 2 and Step 3 where the response is prepared and sent.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'msg' after Step 2?

A {'received': {'text': 'Hello'}}

B None

C {'text': 'Hello'}

D An empty dict

💡 Hint

Check the 'msg' variable in variable_tracker after Step 2.

At which step does FastAPI send the HTTP response back to the client?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Action' column in execution_table for sending response.

If the client sends {'text': 'Hi'} instead, what changes in the execution_table?

A The response is empty

B The 'msg' variable changes to {'text': 'Hi'} at Step 2

C FastAPI will error out

D No change at all

💡 Hint

See how 'msg' tracks input message in variable_tracker.

Concept Snapshot

FastAPI receives HTTP messages as requests.
Define endpoint functions with parameters to get data.
FastAPI parses JSON to Python types automatically.
Return dicts to send JSON responses.
Client sends request, FastAPI processes, then sends response.
This cycle enables sending and receiving messages.

Full Transcript

In FastAPI, sending and receiving messages means the client sends an HTTP request with data, usually JSON. FastAPI receives this request and calls the matching endpoint function. The function parameters tell FastAPI how to convert the incoming JSON into Python objects, like dicts. Inside the function, you can use this data and then return a Python dict. FastAPI converts this dict back to JSON and sends it as the HTTP response. The client then receives this response. This process is a simple request-response cycle where messages are sent and received as JSON data.

Practice

1. What is the main purpose of using Pydantic models in FastAPI when sending and receiving messages?

easy

A. To create HTML templates for message display

B. To manage user authentication tokens

C. To handle database connections automatically

D. To clearly define the structure and data types of messages

Solution

1. Step 1: Understand Pydantic's role in FastAPI

   Pydantic models define how data should look, including types and required fields.

2. Step 2: Connect Pydantic to message handling

   Using Pydantic ensures messages sent or received follow a clear, expected format.

3. Final Answer:

   To clearly define the structure and data types of messages -> Option D

4. Quick Check:

   Pydantic models = message structure [OK]

Hint: Pydantic models describe message shape and types [OK]

Common Mistakes:

• Confusing Pydantic with HTML templating
• Thinking Pydantic manages databases
• Assuming Pydantic handles authentication

2. Which of the following is the correct way to declare a POST endpoint in FastAPI that receives a message model named Message?

easy

A. @app.post('/send')\ndef send_message():\n return Message

B. @app.post('/send')\nasync def send_message(msg: Message):\n return msg

C. @app.get('/send')\nasync def send_message(msg: Message):\n return msg

D. @app.put('/send')\nasync def send_message(msg: Message):\n return msg

Solution

1. Step 1: Identify the HTTP method for sending messages

   POST is used to send data to the server, so @app.post is correct.

2. Step 2: Check function signature for receiving a Pydantic model

   Function must accept a parameter typed as Message to receive the message body.

3. Final Answer:

   @app.post('/send')\nasync def send_message(msg: Message):\n return msg -> Option B

4. Quick Check:

   POST + typed param = correct endpoint [OK]

Hint: Use @app.post and typed parameter for message body [OK]

Common Mistakes:

• Using GET instead of POST for sending data
• Missing parameter type annotation
• Using wrong HTTP method like PUT

3. Given this FastAPI endpoint code, what will be the response when sending a POST request with JSON {"text": "Hello"}?

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Message(BaseModel):
    text: str

@app.post('/echo')
async def echo_message(msg: Message):
    return {"message": msg.text.upper()}

medium

A. {"message": "HELLO"}

B. {"message": "Hello"}

C. {"text": "HELLO"}

D. 500 Internal Server Error

Solution

1. Step 1: Understand the input and model

   The input JSON has key "text" with value "Hello", matching Message model.

2. Step 2: Analyze the endpoint return

   The function returns a dict with key "message" and value as msg.text.upper(), which converts "Hello" to "HELLO".

3. Final Answer:

   {"message": "HELLO"} -> Option A

4. Quick Check:

   Uppercase text returned in 'message' key [OK]

Hint: Look for .upper() call on input text [OK]

Common Mistakes:

• Returning original text without uppercasing
• Returning wrong key name in response
• Expecting an error instead of valid response

4. What is wrong with this FastAPI endpoint code for receiving a message?

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Message(BaseModel):
    content: str

@app.post('/receive')
def receive_message(msg: Message):
    return {"received": msg.content}

medium

A. The endpoint function is missing async keyword

B. The parameter msg should be annotated with Request

C. The endpoint must use @app.get instead of @app.post

D. The function must return a Pydantic model instance

Solution

1. Step 1: Check function declaration for FastAPI async support

   FastAPI supports async endpoints; missing async can cause blocking or warnings.

2. Step 2: Verify parameter and decorator correctness

   Parameter is correctly typed as Message; @app.post is correct for receiving data.

3. Final Answer:

   The endpoint function is missing async keyword -> Option A

4. Quick Check:

   Async keyword needed for async endpoints [OK]

Hint: Use async def for FastAPI POST endpoints [OK]

Common Mistakes:

• Using sync def without async in async context
• Wrong HTTP method decorator
• Incorrect parameter type annotation

5. You want to create a FastAPI endpoint that receives a list of messages, each with a text field, and returns a list of all texts in uppercase. Which code snippet correctly implements this?

hard

A. from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

class Message(BaseModel):
text: str

@app.get('/batch')
def batch_messages(msgs: List[Message]):
return [msg.text.upper() for msg in msgs]

B. from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Message(BaseModel):
text: str

@app.post('/batch')
async def batch_messages(msgs: Message):
return [msg.text.upper() for msg in msgs]

C. from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

class Message(BaseModel):
text: str

@app.post('/batch')
async def batch_messages(msgs: List[Message]):
return [msg.text.upper() for msg in msgs]

D. from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

class Message(BaseModel):
text: str

@app.post('/batch')
async def batch_messages(msgs: List[str]):
return [text.upper() for text in msgs]

Solution

1. Step 1: Use List[Message] to receive multiple messages

   Typing msgs as List[Message] allows FastAPI to parse a list of message objects.

2. Step 2: Return uppercase texts from each message

   List comprehension extracts each msg.text and converts it to uppercase correctly.

3. Final Answer:

   Code snippet with List[Message] parameter and async POST endpoint -> Option C

4. Quick Check:

   List of Message + async POST + uppercase list [OK]

Hint: Use List[Message] and async POST for batch message input [OK]

Common Mistakes:

• Using single Message instead of list
• Using GET instead of POST for sending data
• Typing list as List[str] instead of List[Message]