Skip to content
TheChatArchiveThe Chat Archive
GLMGLM-5 / Pony Alpha· unknownHugging Face Frontier Reasoning Traces

Build a Python web server with asynchronous request handling using aiohttp.

  1. User

    Build a Python web server with asynchronous request handling using aiohttp.

  2. GLM Assistant

    The user wants a Python web server using aiohttp that handles requests asynchronously.

    1. Understand the Goal: The objective is to provide a complete, runnable example of a Python web server using the aiohttp library. Key features to demonstrate:

    • Basic setup (app creation, runner).
    • Route handling (GET, POST).
    • Asynchronous operations (simulating I/O, like database queries or external API calls).
    • JSON response handling.
    • Error handling (basic).

    2. Identify the Prerequisites:

    • Python 3.7+ (for asyncio features).
    • aiohttp library.

    3. Structure the Solution: I should provide a single, self-contained script (or clearly separated files if the user asked for a full project structure, but for a "build a web server" prompt, a single script with explanations is usually best).

    Key components of the script:

    • Imports: aiohttp, asyncio.
    • Handlers:
      • Root/Health check: Simple "Hello World".
      • Async simulation: Use asyncio.sleep to show non-blocking behavior.
      • POST/JSON handling: Accept data and return it.
    • App Factory/Setup: Create the web.Application.
    • Routing: Map paths to handlers.
    • Main entry point: Run the app using web.run_app.

    4. Drafting the Code (Mental or Scratchpad):

    • Import:

      from aiohttp import web
      import asyncio
      
    • Handler 1 (Hello):

      async def handle(request):
          return web.Response(text="Hello, world")
      
    • Handler 2 (Async Work):

      async def long_running(request):
          # Simulate work
          await asyncio.sleep(5)
          return web.Response(text="Done sleeping")
      
    • Handler 3 (JSON):

      async def get_data(request):
          data = {"message": "This is JSON"}
          return web.json_response(data)
      
    • Setup:

      app = web.Application()
      app.add_routes([web.get('/', handle), ...])
      
    • Run:

      if __name__ == '__main__':
          web.run_app(app)
      

    5. Refining the Example: Just the basics are good, but a "realistic" example usually involves:

    • Middleware: Logging or error handling is a nice touch, but maybe keep it simple for the first iteration to avoid overwhelming the user. Let's stick to the core functionality first.
    • Path parameters: Show how to extract data from the URL (e.g., /users/{id}).
    • Query parameters: Show request.query.

    6. Constructing the Explanation:

    • Step 1: Installation. pip install aiohttp.
    • Step 2: The Code. Provide the script.
    • Step 3: Explanation of parts.
      • async def: Explain why handlers are coroutines.
      • web.Response: Standard HTTP response.
      • web.json_response: Helper for APIs.
      • await asyncio.sleep: How to prove it's async.
    • Step 4: Running and Testing. How to start the server and how to curl the endpoints.

    7. Advanced/Best Practices (Optional but helpful): Mentioning AppRunner for low-level control vs web.run_app for standard usage. I'll stick to web.run_app for simplicity, as it's the standard entry point for beginners.

    8. Reviewing the Code Snippet: Let's create a robust example.

    from aiohttp import web
    import asyncio
    import random
    
    async def hello(request):
        return web.Response(text="Hello, world")
    
    async def user_profile(request):
        # Extract path parameter
        user_id = request.match_info.get('id', "Anonymous")
        return web.Response(text=f"User Profile: {user_id}")
    
    async def simulate_io(request):
        # Simulate a database call that takes time
        delay = random.randint(1, 3)
        await asyncio.sleep(delay) # Non-blocking sleep
        return web.json_response({"status": "success", "slept_for": delay})
    
    async def echo_post(request):
        # Read json body
        data = await request.json()
        return web.json_response({"received": data})
    
    app = web.Application()
    app.add_routes([
        web.get('/', hello),
        web.get('/user/{id}', user_profile),
        web.get('/slow', simulate_io),
        web.post('/echo', echo_post),
    ])
    
    if __name__ == '__main__':
        web.run_app(app, port=8080)
    

    9. Final Polish: Ensure the explanation highlights why aiohttp is good (handling many concurrent connections on the slow endpoint without blocking threads).

    10. Output Generation: (Proceed to generate the response based on these thoughts.) Here is a complete guide to building an asynchronous web server using aiohttp.

    Prerequisites

    First, you need to install the aiohttp library:

    pip install aiohttp
    

    The Python Server Code

    Save the following code into a file named server.py.

    This example demonstrates:

    1. Basic Routing: Handling simple GET requests.
    2. Path Parameters: Extracting data from the URL (e.g., /users/123).
    3. Asynchronous Logic: Simulating a database call or external API request using asyncio.sleep without blocking the server.
    4. JSON Handling: Reading JSON from a POST request and returning a JSON response.
    from aiohttp import web
    import asyncio
    import random
    
    # 1. Basic Route Handler
    async def handle_root(request):
        """
        A simple handler that returns a text response.
        """
        print("Root endpoint hit")
        return web.Response(text="Welcome to the Async Server!")
    
    # 2. Handler with Path Parameters
    async def get_user(request):
        """
        Extracts 'user_id' from the URL path.
        Example: /users/42
        """
        user_id = request.match_info.get('user_id', 'anonymous')
        message = f"Requested profile for User ID: {user_id}"
        return web.Response(text=message)
    
    # 3. Asynchronous "Long" Running Task
    async def simulate_external_api(request):
        """
        Simulates a non-blocking I/O operation (like a DB query).
        The server can handle other requests while this waits.
        """
        print("Starting async task...")
        
        # Generate a random wait time between 1 and 3 seconds
        wait_time = random.uniform(1, 3)
        
        # Asynchronously sleep (non-blocking)
        await asyncio.sleep(wait_time)
        
        print(f"Async task finished after {wait_time:.2f} seconds")
        return web.json_response({
            "status": "success",
            "message": f"Waited for {wait_time:.2f} seconds asynchronously"
        })
    
    # 4. POST Request with JSON
    async def create_post(request):
        """
        Reads JSON data sent by the client and echoes it back.
        """
        try:
            # Read the JSON body asynchronously
            data = await request.json()
            
            # Process data (here we just add an ID)
            data['server_id'] = random.randint(1000, 9999)
            
            return web.json_response({
                "status": "created",
                "received_data": data
            })
        except Exception as e:
            return web.json_response({"error": "Invalid JSON"}, status=400)
    
    # App Factory
    def create_app():
        app = web.Application()
        
        # Define routes
        app.add_routes([
            web.get('/', handle_root),
            web.get('/users/{user_id}', get_user),
            web.get('/slow-task', simulate_external_api),
            web.post('/submit', create_post),
        ])
        
        return app
    
    if __name__ == '__main__':
        app = create_app()
        print("Server starting at http://0.0.0.0:8080")
        # web.run_app starts the event loop
        web.run_app(app, host='0.0.0.0', port=8080)
    

    How to Run and Test

    1. Start the server: Run the script in your terminal:

    python server.py
    

    2. Test the endpoints: Open a separate terminal window to make requests using curl.

    • Root Endpoint:

      curl http://localhost:8080/
      
    • Path Parameter:

      curl http://localhost:8080/users/55
      
    • Async Task:

      curl http://localhost:8080/slow-task
      

      (Note: This will take 1-3 seconds to return, but the server remains free to handle other requests in the meantime.)

    • POST JSON Data:

      curl -X POST http://localhost:8080/submit \
           -H "Content-Type: application/json" \
           -d '{"name": "Alice", "job": "Developer"}'
      

    Key Concepts Used

    1. async def: All route handlers are defined as asynchronous functions. This allows Python to pause their execution (for I/O) and switch to other tasks.
    2. await: Used inside the handlers to call operations that take time (like request.json() or asyncio.sleep). This yields control back to the event loop.
    3. web.Response vs web.json_response:
      • web.Response is generic (usually for text/html).
      • web.json_response automatically serializes a Python dictionary to JSON and sets the correct headers.
    4. web.Application(): The container for your routes and configuration.
    5. web.run_app(): The high-level entry point that creates the event loop and starts the HTTP server.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.