WSGI concept overview in Flask - Step-by-Step Execution

Concept Flow - WSGI concept overview

Client sends HTTP request

↓

WSGI Server receives request

↓

WSGI Server calls Flask app callable

↓

Flask app processes request

↓

Flask app returns status, headers, body

↓

WSGI Server sends HTTP response back to client

This flow shows how a WSGI server acts as a middleman between the client and the Flask app, passing requests and responses.

Execution Sample

Flask

from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return 'Hello, WSGI!'

if __name__ == '__main__':
    app.run()

A simple Flask app that returns 'Hello, WSGI!' when the root URL is accessed.

Execution Table

Step	Action	Input	Output	Notes
1	Client sends HTTP GET request to '/'	GET /	Request received by WSGI server	Client initiates communication
2	WSGI server calls Flask app callable	Request environment dict	Flask app function called	WSGI server passes request info
3	Flask app matches route '/'	Request path '/'	Calls home() function	Routing decides which function to run
4	home() returns response body	None	'Hello, WSGI!'	Function returns string response
5	Flask app returns status, headers, body	Response body	('200 OK', headers, [body])	WSGI expects this tuple
6	WSGI server sends HTTP response	Response tuple	HTTP 200 OK with body 'Hello, WSGI!'	Client receives response
7	Client displays response	HTTP response	Page shows 'Hello, WSGI!'	User sees output in browser

💡 Request cycle ends after response is sent back to client

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
request	None	{'REQUEST_METHOD': 'GET', 'PATH_INFO': '/'}	{'REQUEST_METHOD': 'GET', 'PATH_INFO': '/'}	Passed to home()	Used to generate response
response_body	None	None	None	'Hello, WSGI!'	'Hello, WSGI!'
status	None	None	None	'200 OK'	'200 OK'
headers	None	None	None	{'Content-Type': 'text/html; charset=utf-8'}	{'Content-Type': 'text/html; charset=utf-8'}

Key Moments - 3 Insights

Why does the WSGI server call the Flask app like a function?

Because Flask apps are designed as callable objects that accept the request environment and return a response tuple, as shown in step 2 of the execution table.

What does the Flask app return to the WSGI server?

It returns a tuple with the status string, headers dictionary, and response body iterable, as shown in step 5 of the execution table.

How does the client get the final response?

The WSGI server sends the HTTP response back to the client after receiving the response tuple from Flask, as shown in step 6.

Visual Quiz - 3 Questions

Look at the execution table, what does the Flask app return at step 5?

A A tuple with status, headers, and body

B An HTTP request

C A function call

D A client request

💡 Hint

Check the 'Output' column in step 5 of the execution table

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

A Step 2

B Step 3

C Step 6

D Step 7

💡 Hint

Look for the step where 'WSGI server sends HTTP response' in the 'Action' column

If the Flask app returned a different status code, which variable in the variable tracker would change?

A request

B status

C response_body

D headers

💡 Hint

Check the 'status' variable row in the variable tracker

Concept Snapshot

WSGI is a standard interface between web servers and Python web apps.
The server calls the app callable with request info.
The app returns a status, headers, and body tuple.
The server sends this as an HTTP response to the client.
Flask apps follow this pattern to handle requests.

Full Transcript

WSGI stands for Web Server Gateway Interface. It is a standard way for web servers to communicate with Python web applications like Flask. When a client sends an HTTP request, the WSGI server receives it and calls the Flask app as a function, passing request details. The Flask app processes the request, runs the matching route function, and returns a response tuple containing the status, headers, and body. The WSGI server then sends this response back to the client. This process allows Flask apps to work with many different web servers in a consistent way.

Practice

1. What is the main role of WSGI in a Flask web application?

easy

A. It acts as a bridge between the web server and the Python application.

B. It stores the application's database connections.

C. It manages user sessions and cookies.

D. It handles the frontend HTML and CSS rendering.

Solution

1. Step 1: Understand WSGI's purpose

   WSGI stands for Web Server Gateway Interface and connects web servers with Python apps.

2. Step 2: Identify WSGI's role in Flask

   Flask apps use WSGI to receive requests from servers and send responses back.

3. Final Answer:

   It acts as a bridge between the web server and the Python application. -> Option A

4. Quick Check:

   WSGI = bridge between server and app [OK]

Hint: WSGI connects server and Python app like a translator [OK]

Common Mistakes:

• Confusing WSGI with frontend rendering
• Thinking WSGI manages databases
• Assuming WSGI handles user sessions

2. Which of the following is the correct signature of a WSGI application callable?

easy

A. def app(request, response):

B. def app():

C. def app(request):

D. def app(environ, start_response):

Solution

1. Step 1: Recall WSGI callable signature

   A WSGI app is a function that takes two arguments: environ and start_response.

2. Step 2: Match the correct function signature

   Only def app(environ, start_response): matches the required parameters for a WSGI callable.

3. Final Answer:

   def app(environ, start_response): -> Option D

4. Quick Check:

   WSGI callable = (environ, start_response) [OK]

Hint: WSGI apps always take environ and start_response [OK]

Common Mistakes:

• Using request and response instead of environ and start_response
• Missing one or both parameters
• Defining a function with no parameters

3. Given this WSGI app snippet, what will be the response body sent to the client?

def app(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/plain')])
    return [b'Hello, WSGI!']

medium

A. An empty response with status 200

B. A server error due to missing return type

C. The text 'Hello, WSGI!' displayed in the browser

D. A response with HTML content

Solution

1. Step 1: Analyze start_response call

   The status is '200 OK' and content type is 'text/plain', so plain text will be sent.

2. Step 2: Check the return value

   The app returns a list with a byte string containing 'Hello, WSGI!'. This is the response body.

3. Final Answer:

   The text 'Hello, WSGI!' displayed in the browser -> Option C

4. Quick Check:

   Return byte string with 'Hello, WSGI!' = The text 'Hello, WSGI!' displayed in the browser [OK]

Hint: Return a byte string list for response body in WSGI [OK]

Common Mistakes:

• Returning a string instead of bytes
• Not calling start_response before returning
• Expecting HTML content without setting content-type

4. Identify the error in this WSGI application code:

def app(environ, start_response):
    start_response('200 OK')
    return [b'Hello']

medium

A. The function should not take any parameters.

B. Missing the headers argument in start_response call.

C. The return value should be a string, not bytes.

D. start_response should be called after returning the response.

Solution

1. Step 1: Check start_response usage

   start_response requires two arguments: status and headers list. Here headers are missing.

2. Step 2: Validate return type and function signature

   Return type is correct as a list of bytes, and parameters are correct.

3. Final Answer:

   Missing the headers argument in start_response call. -> Option B

4. Quick Check:

   start_response needs headers list [OK]

Hint: start_response needs status and headers list [OK]

Common Mistakes:

• Omitting headers argument in start_response
• Returning string instead of bytes
• Calling start_response after return

5. You want to create a WSGI app that returns 'Welcome!' only if the URL path is '/home', otherwise returns 'Not Found' with status 404. Which code correctly implements this?

hard

A. def app(environ, start_response):
if environ['PATH_INFO'] == '/home':
start_response('200 OK', [('Content-Type', 'text/plain')])
return [b'Welcome!']
else:
start_response('404 Not Found', [('Content-Type', 'text/plain')])
return [b'Not Found']

B. def app(environ, start_response):
if environ['PATH_INFO'] == '/home':
return [b'Welcome!']
else:
start_response('404 Not Found', [('Content-Type', 'text/plain')])
return [b'Not Found']

C. def app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
return [b'Welcome!']

D. def app(environ, start_response):
start_response('404 Not Found')
return [b'Not Found']

Solution

1. Step 1: Check URL path handling

   Use environ['PATH_INFO'] to check the requested path; only '/home' returns 'Welcome!'.

2. Step 2: Verify start_response calls and return values

   Both cases call start_response with correct status and headers, and return byte strings in a list.

3. Final Answer:

   The code that checks environ['PATH_INFO'] == '/home' and calls start_response in both branches. -> Option A

4. Quick Check:

   Check PATH_INFO and call start_response properly [OK]

Hint: Always call start_response before returning response [OK]

Common Mistakes:

• Not calling start_response in all branches
• Returning bytes without start_response
• Ignoring PATH_INFO for routing