Why WebSockets enable real-time communication in FastAPI - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the WebSocket class from FastAPI.

FastAPI

from fastapi import [1]

Drag options to blanks, or click blank then click option'

AResponse

BWebSocket

CRequest

DDepends

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Request or Response instead of WebSocket.

Forgetting to import WebSocket causes errors when using it.

The WebSocket class is imported from FastAPI to handle WebSocket connections.

2fill in blank

medium

Complete the code to accept a WebSocket connection inside an endpoint.

FastAPI

async def websocket_endpoint(websocket: WebSocket):
    await websocket.[1]()

Drag options to blanks, or click blank then click option'

Aaccept

Bclose

Csend_text

Dreceive_text

Attempts:

3 left

💡 Hint

Common Mistakes

Calling send_text before accepting the connection.

Not calling accept causes the connection to be rejected.

The accept() method is called to accept the WebSocket connection from the client.

3fill in blank

hard

Fix the error in the code to receive a message from the client.

FastAPI

data = await websocket.[1]()

Drag options to blanks, or click blank then click option'

Asend_text

Baccept

Creceive_text

Dclose

Attempts:

3 left

💡 Hint

Common Mistakes

Using send_text instead of receive_text.

Trying to accept or close instead of receiving data.

The receive_text() method receives a text message from the client over the WebSocket.

4fill in blank

hard

Fill both blanks to send a message back to the client with the received data.

FastAPI

await websocket.[1](text='Message received: ' + [2])

Drag options to blanks, or click blank then click option'

Asend_text

Bdata

Creceive_text

Daccept

Attempts:

3 left

💡 Hint

Common Mistakes

Using receive_text instead of send_text to send data.

Using accept or close instead of send_text.

Using receive_text or accept instead of the data variable.

Use send_text to send a message, and data is the variable holding the received message.

5fill in blank

hard

Fill all three blanks to create a simple FastAPI WebSocket app that echoes messages.

FastAPI

from fastapi import FastAPI, [1]

app = FastAPI()

@app.websocket('/ws')
async def websocket_endpoint(websocket: [2]):
    await websocket.[3]()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f'Echo: {data}')

Drag options to blanks, or click blank then click option'

AWebSocket

BRequest

Caccept

DResponse

Attempts:

3 left

💡 Hint

Common Mistakes

Using Request or Response instead of WebSocket.

Forgetting to call accept() before communication.

Import WebSocket, use it as the parameter type, and call accept() to start the connection.

Practice

1. Why do WebSockets enable real-time communication in FastAPI applications?

easy

A. Because they only send data from server to client once

B. Because they use HTTP requests repeatedly to fetch new data

C. Because they keep a constant open connection for instant two-way data exchange

D. Because they require manual page refresh to update data

Solution

1. Step 1: Understand WebSocket connection behavior

   WebSockets maintain a persistent connection allowing continuous data flow without reconnecting.

2. Step 2: Compare with HTTP request-response model

   Unlike HTTP, which closes after each request, WebSockets allow instant two-way communication.

3. Final Answer:

   Because they keep a constant open connection for instant two-way data exchange -> Option C

4. Quick Check:

   Persistent connection = real-time communication [OK]

Hint: Remember: WebSockets keep connection open for instant updates [OK]

Common Mistakes:

• Confusing WebSockets with repeated HTTP requests
• Thinking WebSockets only send data one way
• Assuming page refresh is needed for updates

2. Which of the following is the correct way to define a WebSocket route in FastAPI?

easy

A. app.websocket('/ws') async def websocket_endpoint(websocket): await websocket.accept()

B. app.get('/ws') async def websocket_endpoint(websocket): await websocket.accept()

C. app.post('/ws') def websocket_endpoint(websocket): websocket.accept()

D. app.websocket('/ws') def websocket_endpoint(): websocket.accept()

Solution

1. Step 1: Identify correct decorator and async function

   FastAPI uses @app.websocket decorator and async def for WebSocket routes.

2. Step 2: Confirm usage of await websocket.accept()

   Accepting the connection requires awaiting websocket.accept() inside async function.

3. Final Answer:

   app.websocket('/ws') async def websocket_endpoint(websocket): await websocket.accept() -> Option A

4. Quick Check:

   Use @app.websocket + async + await accept() [OK]

Hint: WebSocket routes need @app.websocket and async functions [OK]

Common Mistakes:

• Using HTTP method decorators like @app.get for WebSockets
• Forgetting async or await keywords
• Defining function without websocket parameter

3. Given this FastAPI WebSocket code snippet, what will the client receive after sending 'hello'?

from fastapi import FastAPI, WebSocket
app = FastAPI()

@app.websocket('/ws')
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    data = await websocket.receive_text()
    await websocket.send_text(f'Received: {data}')

medium

A. 'hello'

B. Error: websocket not accepted

C. No response, connection closed

D. 'Received: hello'

Solution

1. Step 1: Analyze the receive and send calls

   The server waits for text, receives 'hello', then sends back 'Received: hello'.

2. Step 2: Confirm connection acceptance

   websocket.accept() is awaited, so connection is open and ready for communication.

3. Final Answer:

   'Received: hello' -> Option D

4. Quick Check:

   Server echoes with prefix 'Received:' [OK]

Hint: Look for send_text with formatted string after receive_text [OK]

Common Mistakes:

• Assuming no response is sent
• Ignoring the awaited accept() call
• Confusing received data with sent data

4. What is wrong with this FastAPI WebSocket handler code?

@app.websocket('/ws')
async def websocket_endpoint(websocket: WebSocket):
    data = await websocket.receive_text()
    await websocket.accept()
    await websocket.send_text(f'Got: {data}')

medium

A. Incorrect route decorator used

B. Calling receive_text before accepting the connection

C. Using send_text instead of send_bytes

D. Missing async keyword in function definition

Solution

1. Step 1: Check order of accept and receive calls

   WebSocket connection must be accepted before receiving data.

2. Step 2: Identify the error caused by wrong order

   Calling receive_text before accept() causes runtime error as connection is not open yet.

3. Final Answer:

   Calling receive_text before accepting the connection -> Option B

4. Quick Check:

   Accept connection before receiving data [OK]

Hint: Always await websocket.accept() before receiving messages [OK]

Common Mistakes:

• Receiving data before accepting connection
• Forgetting async keyword
• Confusing send_text with send_bytes

5. You want to build a live chat app using FastAPI WebSockets. Which approach best ensures real-time updates to all connected clients?

hard

A. Keep a list of connected WebSocket objects and broadcast messages to all

B. Send HTTP requests every second to fetch new messages

C. Open a new WebSocket connection for each message sent

D. Use a database trigger to push messages without WebSockets

Solution

1. Step 1: Understand real-time broadcast requirement

   To update all clients instantly, server must send messages to all open connections.

2. Step 2: Identify best method for broadcasting

   Maintaining a list of connected WebSocket objects allows sending messages to all clients immediately.

3. Final Answer:

   Keep a list of connected WebSocket objects and broadcast messages to all -> Option A

4. Quick Check:

   Broadcast via open WebSocket connections = real-time updates [OK]

Hint: Broadcast by storing and sending to all connected sockets [OK]

Common Mistakes:

• Using repeated HTTP polling instead of WebSockets
• Opening new connections per message wastes resources
• Relying on database triggers without WebSocket communication