# WSGI application (synchronous)
def wsgi_app(environ, start_response):
    status = '200 OK'
    headers = [('Content-Type', 'text/plain')]
    start_response(status, headers)
    return [b'Hello from WSGI']

# ASGI application (asynchronous)
async def asgi_app(scope, receive, send):
    await send({
        'type': 'http.response.start',
        'status': 200,
        'headers': [[b'content-type', b'text/plain']],
    })
    await send({
        'type': 'http.response.body',
        'body': b'Hello from ASGI',
    })

# settings.py for production
ALLOWED_HOSTS = ['example.com', 'www.example.com']
STATIC_ROOT = '/var/www/static/'
MEDIA_ROOT = '/var/www/media/'

# Database connection pooling
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'CONN_MAX_AGE': 600,
        'OPTIONS': {'connect_timeout': 10},
    }
}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

@app.post("/items/")
async def create_item(item: Item):
    return {"item": item, "status": "created"}

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id not in item_db:
        raise HTTPException(status_code=404, detail="Item not found")
    return item_db[item_id]

# Strawberry example (modern approach)
import strawberry
from typing import List

@strawberry.type
class Book:
    title: str
    author: str
    year: int

@strawberry.type
class Query:
    @strawberry.field
    def books(self) -> List[Book]:
        return [
            Book(title="1984", author="George Orwell", year=1949),
            Book(title="Brave New World", author="Aldous Huxley", year=1932),
        ]

schema = strawberry.Schema(query=Query)

from fastapi import FastAPI, Query
from typing import Optional

app = FastAPI()

@app.get("/api/v1/users")
async def list_users(
    page: int = Query(1, ge=1),
    page_size: int = Query(50, ge=1, le=100),
    filter_role: Optional[str] = None
):
    offset = (page - 1) * page_size
    users = get_users(offset, page_size, filter_role)
    return {
        "data": users,
        "pagination": {
            "page": page,
            "page_size": page_size,
            "total": get_total_users(filter_role)
        }
    }

import boto3
from botocore.exceptions import ClientError

# High-level resource API
s3 = boto3.resource('s3')
bucket = s3.Bucket('my-bucket')

# Upload file with metadata
bucket.upload_file(
    '/tmp/data.csv',
    'uploads/data.csv',
    ExtraArgs={'Metadata': {'uploaded-by': 'pipeline'}}
)

# Low-level client API for fine-grained control
s3_client = boto3.client('s3')
try:
    response = s3_client.get_object(Bucket='my-bucket', Key='data.csv')
    data = response['Body'].read()
except ClientError as e:
    if e.response['Error']['Code'] == 'NoSuchKey':
        print("File not found")

import json
import os
import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['TABLE_NAME'])

def lambda_handler(event, context):
    try:
        # Parse input
        body = json.loads(event['body'])
        item_id = body['id']

        # Process
        response = table.get_item(Key={'id': item_id})

        # Return success
        return {
            'statusCode': 200,
            'headers': {'Content-Type': 'application/json'},
            'body': json.dumps(response.get('Item', {}))
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }

# main.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

resource "aws_lambda_function" "api_handler" {
  filename         = "lambda.zip"
  function_name    = "api-handler"
  role            = aws_iam_role.lambda_role.arn
  handler         = "main.lambda_handler"
  runtime         = "python3.11"
  timeout         = 30
  memory_size     = 512

  environment {
    variables = {
      TABLE_NAME = aws_dynamodb_table.main.name
    }
  }
}

# Task definition for Python API
{
  "family": "python-api",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "containerDefinitions": [
    {
      "name": "api",
      "image": "123456789.dkr.ecr.us-east-1.amazonaws.com/python-api:latest",
      "portMappings": [{"containerPort": 8000, "protocol": "tcp"}],
      "environment": [
        {"name": "DATABASE_URL", "value": "postgresql://..."}
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/python-api",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ]
}