Python’s asyncio module explained

in

If you haven’t heard of it yet, let me break it down for ya.

asyncio is a library in Python that allows us to write concurrent code using the async/await syntax. .. mostly).

But before we dive into how it works, let me first explain why you should care about asyncio in the first place. Imagine you have a web server that needs to handle thousands of requests simultaneously. Without asyncio, your code would look something like this:

# Import necessary modules
import time # Import the time module to use the sleep function
from http import server # Import the server module from the http library

# Create a class for handling HTTP requests
class Handler(server.BaseHTTPRequestHandler):
    # Define a method for handling GET requests
    def do_GET(self):
        # Send a 200 response code
        self.send_response(200)
        # Set the content type header to text/plain
        self.send_header('Content-type', 'text/plain')
        # End the headers
        self.end_headers()
        # Simulate a slow database query or something by sleeping for 1 second
        time.sleep(1)
        # Write the response to the client
        self.wfile.write("Hello, world!".encode())
        # Flush the output buffer
        self.wfile.flush()

# Create an instance of the HTTP server on port 80, using the Handler class to handle requests
httpd = server.HTTPServer(('', 80), Handler)
# Print a message to indicate that the server is running
print('Serving HTTP on port 80...')
try:
    # Start the server and keep it running until a keyboard interrupt is received
    httpd.serve_forever()
except KeyboardInterrupt:
    # Close the server if a keyboard interrupt is received
    httpd.server_close()

This code is fine for a small-scale web server, but as the number of requests increases, it becomes slower and less efficient. That’s where asyncio comes in by using coroutines (which are like functions that can pause themselves) and event loops (which manage those coroutines), we can write concurrent code without sacrificing performance or sanity.

Here’s how you would rewrite the above example with asyncio:

# Import necessary modules
import time # Import the time module for time-related functions
from http import server # Import the server module from the http library
import asyncio # Import the asyncio module for asynchronous programming

# Create a class for handling HTTP requests
class Handler(server.BaseHTTPRequestHandler):
    # Define a method for handling GET requests
    def do_GET(self):
        self.send_response(200) # Send a 200 response code
        self.send_header('Content-type', 'text/plain') # Set the content type header
        self.end_headers() # End the headers section
        # Simulate a slow database query or something
        asyncio.sleep(1) # Use the asyncio sleep function to pause execution for 1 second
        self.wfile.write("Hello, world!".encode()) # Write the response to the client
        self.wfile.flush() # Flush the output buffer to ensure all data is sent

# Create a custom HTTP server class
class WSGIServer(server.HTTPServer):
    # Define the constructor with necessary parameters
    def __init__(self, handler_class, address=('', 80), request_handler=None):
        super().__init__(address, request_handler) # Call the constructor of the parent class
        self.handler_class = handler_class # Set the handler class attribute

    # Define a method for handling requests
    async def handle_request(self, request, client, server):
        # Create a new coroutine for each request
        handler = self.handler_class(client, server)
        # Run the coroutine in an event loop
        await handler.process_request()

# Define the main function
async def main():
    # Create an instance of the custom HTTP server class
    server = WSGIServer(Handler)
    # Start the event loop and pass it the server instance
    asyncio.get_event_loop().run_until_complete(server.serve_forever())

# Check if the script is being run directly
if __name__ == '__main__':
    # Run the main function in an event loop
    asyncio.run(main())

As you can see, we’ve replaced the `httpd.serve_forever()` call with a custom WSGIServer class that uses coroutines to handle each request separately. This allows us to write concurrent code without sacrificing performance or sanity (well… mostly).

Give it a try and let me know what you think in the comments below I promise not to judge if you use too many exclamation points or emojis.

SICORPS