Polling as fallback in Flask - Step-by-Step Execution

Concept Flow - Polling as fallback

Client sends request

↓

Server receives request

↓

Server checks for new data

Yes No↓

Send data

↓

Client updates UI

↓

Wait fixed time

↩Back to Client sends request

The client repeatedly asks the server for updates. If new data exists, server sends it; otherwise, it sends an empty response. The client waits then asks again.

Execution Sample

Flask

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

@app.route('/poll')
def poll():
    if new_data_available():
        return jsonify({'data': 'new info'})
    return jsonify({'data': None})

This Flask route checks if new data is available and returns it; otherwise, it returns None as fallback.

Execution Table

Step	Client Request	Server Checks new_data_available()	Server Response	Client Action
1	Sends /poll request	True	Returns {'data': 'new info'}	Updates UI with new info
2	Sends /poll request	False	Returns {'data': None}	No UI update
3	Sends /poll request	False	Returns {'data': None}	No UI update
4	Sends /poll request	True	Returns {'data': 'new info'}	Updates UI with new info
5	Sends /poll request	False	Returns {'data': None}	No UI update
Exit	Stops polling	-	-	Polling ends or continues based on client logic

💡 Polling stops when client decides or page unloads; otherwise, it loops continuously.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	Final
new_data_available()	N/A	True	False	False	True	False	N/A
Server Response	N/A	{'data': 'new info'}	{'data': None}	{'data': None}	{'data': 'new info'}	{'data': None}	N/A
Client UI	Empty	Updated	No change	No change	Updated	No change	Depends on client

Key Moments - 2 Insights

Why does the client keep sending requests even when no new data is available?

Because polling is a fallback method where the client repeatedly asks the server at fixed intervals, even if no new data is ready, as shown in execution_table rows 2 and 3.

What happens on the server when no new data is available?

The server returns a response with data set to None, indicating no update, as seen in execution_table rows 2, 3, and 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the server response at step 4?

A {'data': None}

B {'data': 'new info'}

C No response

D Error message

💡 Hint

Check the 'Server Response' column at step 4 in the execution_table.

At which step does the client update the UI with new data?

A Step 1

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'Client Action' column for steps where UI updates happen.

If new_data_available() always returns False, what changes in the execution table?

A Server always returns new info

B Client never sends requests

C Server always returns {'data': None}

D Client updates UI every step

💡 Hint

Refer to the 'Server Checks new_data_available()' and 'Server Response' columns.

Concept Snapshot

Polling as fallback in Flask:
- Client sends repeated requests to server endpoint.
- Server checks for new data each request.
- If new data exists, server sends it; else sends empty response.
- Client updates UI only on new data.
- Polling repeats after fixed wait time as fallback when push not available.

Full Transcript

Polling as fallback means the client keeps asking the server for updates at regular intervals. The server checks if new data is available. If yes, it sends the data back. If no, it sends an empty response. The client updates the user interface only when new data arrives. This cycle repeats until the client stops polling. This method is simple and works when more advanced push methods are not possible.

Practice

1. What is the main reason to use polling as a fallback in Flask applications?

easy

A. To regularly ask the server for updates when real-time methods fail

B. To reduce the number of server requests to zero

C. To make the server push updates automatically without client requests

D. To avoid any communication between client and server

Solution

1. Step 1: Understand polling purpose

   Polling sends repeated requests to the server to check for updates.

2. Step 2: Identify fallback use

   Polling is used when real-time communication methods like WebSockets are unavailable or fail.

3. Final Answer:

   To regularly ask the server for updates when real-time methods fail -> Option A

4. Quick Check:

   Polling = fallback for updates [OK]

Hint: Polling means repeated requests when real-time fails [OK]

Common Mistakes:

• Thinking polling reduces server requests
• Confusing polling with server push
• Believing polling stops communication

2. Which Flask code snippet correctly implements a simple polling endpoint that returns JSON data?

easy

A. from flask import Flask
app = Flask(__name__)

@app.route('/poll')
def poll():
return {'status': 'ok', 'time': datetime.now()}

B. from flask import Flask
app = Flask(__name__)

@app.route('/poll')
def poll():
return 'status: ok'

C. from flask import Flask, json
app = Flask(__name__)

@app.route('/poll')
def poll():
return json.dumps({'status': 'ok'})

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

@app.route('/poll')
def poll():
return jsonify({'status': 'ok'})

Solution

1. Step 1: Check Flask imports and response format

   Using jsonify is the correct way to return JSON responses in Flask.

2. Step 2: Verify route and function syntax

   from flask import Flask, jsonify app = Flask(__name__) @app.route('/poll') def poll(): return jsonify({'status': 'ok'}) uses @app.route and returns jsonify({'status': 'ok'}) correctly.

3. Final Answer:

   Correct Flask polling endpoint returning JSON with jsonify -> Option D

4. Quick Check:

   jsonify for JSON response = from flask import Flask, jsonify app = Flask(__name__) @app.route('/poll') def poll(): return jsonify({'status': 'ok'}) [OK]

Hint: Use jsonify to return JSON responses in Flask [OK]

Common Mistakes:

• Returning plain string instead of JSON
• Using json.dumps without Response object
• Returning dict directly without jsonify

3. Given this Flask polling endpoint code, what will the client receive when requesting '/poll'?

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

@app.route('/poll')
def poll():
    data = {'message': 'Hello', 'count': 5}
    return jsonify(data)

medium

A. Hello 5

B. {"message": "Hello", "count": 5}

C. {message: Hello, count: 5}

D. Error: jsonify not defined

Solution

1. Step 1: Understand jsonify output

   jsonify converts Python dict to JSON string with double quotes and correct syntax.

2. Step 2: Check returned data format

   The returned JSON string will be {"message": "Hello", "count": 5} as a JSON response.

3. Final Answer:

   {"message": "Hello", "count": 5} -> Option B

4. Quick Check:

   jsonify returns JSON string = {"message": "Hello", "count": 5} [OK]

Hint: jsonify returns JSON string with double quotes [OK]

Common Mistakes:

• Expecting plain text instead of JSON
• Confusing Python dict syntax with JSON
• Assuming jsonify is undefined

4. Identify the error in this Flask polling endpoint code:

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

@app.route('/poll')
def poll():
    data = {'status': 'ok'}

medium

A. Function poll() is missing a return statement

B. Missing @app.route decorator

C. Flask app is not created properly

D. Returning a dict directly without using jsonify causes an error

Solution

1. Step 1: Check for return statement

   The poll() function defines data but does not return it.

2. Step 2: Verify function completeness

   Missing return statement means the endpoint returns None by default, causing unexpected empty response.

3. Final Answer:

   Function poll() is missing a return statement -> Option A

4. Quick Check:

   Missing return in view function [OK]

Hint: Always include return statement in Flask route handlers [OK]

Common Mistakes:

• Missing return statement in route function
• Forgetting route decorator
• Not creating Flask app instance

5. You want to implement polling as a fallback in a Flask app that first tries WebSocket for real-time updates. Which approach correctly combines both methods?

hard

A. Use WebSocket and polling simultaneously without fallback logic

B. Only use polling and ignore WebSocket support

C. Use WebSocket for updates; if unsupported, client polls '/poll' endpoint every 5 seconds

D. Use polling only on the server side without client requests

Solution

1. Step 1: Understand fallback strategy

   Fallback means trying WebSocket first, then polling if WebSocket fails or is unsupported.

2. Step 2: Identify correct client-server interaction

   Client tries WebSocket; if it fails, client sends repeated requests to '/poll' endpoint every few seconds.

3. Final Answer:

   Use WebSocket for updates; if unsupported, client polls '/poll' endpoint every 5 seconds -> Option C

4. Quick Check:

   Fallback = WebSocket then polling [OK]

Hint: Try WebSocket first, then poll if needed [OK]

Common Mistakes:

• Ignoring fallback and using only polling
• Using polling without client requests
• Running both methods without fallback logic