Build Fault-Tolerant Supply Chain Agents with Claude Agent SDK and FastAPI

"""
Production implementation for building fault-tolerant supply chain agents using Claude Agent SDK and FastAPI.
Provides secure, scalable operations with robust error handling and logging.
"""

from typing import Dict, Any, List
import os
import logging
import httpx
from fastapi import FastAPI, HTTPException, Request
from pydantic import BaseModel, ValidationError
from sqlalchemy import create_engine, text
from sqlalchemy.orm import sessionmaker, Session
import time

# Logger setup
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Configuration class
class Config:
    database_url: str = os.getenv('DATABASE_URL', 'sqlite:///./test.db')  # Default to SQLite for testing
    max_retries: int = 5
    retry_delay: float = 2.0

# Database connection pooling
engine = create_engine(Config.database_url, connect_args={'check_same_thread': False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# Data model
class SupplyChainEvent(BaseModel):
    event_id: int
    event_type: str
    payload: Dict[str, Any]

# Validate input data
async def validate_input(data: Dict[str, Any]) -> bool:
    """Validate request data.
    Args:
        data: Input to validate
    Returns:
        True if valid
    Raises:
        ValueError: If validation fails
    """
    if 'event_id' not in data or 'event_type' not in data:
        raise ValueError('Missing event_id or event_type')
    return True

# Sanitize fields
def sanitize_fields(data: Dict[str, Any]) -> Dict[str, Any]:
    """Sanitize input data fields.
    Args:
        data: Input data to sanitize
    Returns:
        Sanitized data
    """
    return {key: str(value).strip() for key, value in data.items()}

# Fetch data from Claude Agent SDK
async def fetch_data(api_url: str) -> Dict[str, Any]:
    """Fetch data from external API.
    Args:
        api_url: URL of the API to call
    Returns:
        Response data
    Raises:
        HTTPException: If fetching data fails
    """
    try:
        async with httpx.AsyncClient() as client:
            response = await client.get(api_url)
            response.raise_for_status()  # Raise HTTPError for bad responses
            return response.json()
    except httpx.HTTPStatusError as e:
        logger.error(f'HTTP error occurred: {e}')
        raise HTTPException(status_code=e.response.status_code, detail=str(e))
    except Exception as e:
        logger.error(f'An error occurred: {e}')
        raise HTTPException(status_code=500, detail='Internal Server Error')

# Save data to database
async def save_to_db(db: Session, event: SupplyChainEvent) -> None:
    """Save supply chain event to database.
    Args:
        db: Database session
        event: SupplyChainEvent to save
    Raises:
        Exception: If saving fails
    """
    try:
        db.execute(text('INSERT INTO events (event_id, event_type, payload) VALUES (:id, :type, :payload)'),
                   {'id': event.event_id, 'type': event.event_type, 'payload': event.json()})
        db.commit()
    except Exception as e:
        logger.error(f'Failed to save event: {e}')
        db.rollback()
        raise

# Process batch of events
async def process_batch(events: List[Dict[str, Any]]) -> None:
    """Process a batch of supply chain events.
    Args:
        events: List of events to process
    Raises:
        Exception: If processing fails
    """
    for event_data in events:
        try:
            await validate_input(event_data)  # Validate input
            sanitized_data = sanitize_fields(event_data)  # Sanitize fields
            event = SupplyChainEvent(**sanitized_data)  # Create event object
            with SessionLocal() as db:
                await save_to_db(db, event)  # Save to DB
        except ValueError as e:
            logger.warning(f'Validation error: {e}')  # Log validation errors
        except Exception as e:
            logger.error(f'Processing error: {e}')  # Log other errors

# Main FastAPI app
app = FastAPI()

@app.post('/events/')
async def create_event(request: Request):
    """Create a new supply chain event.
    Args:
        request: HTTP request containing event data
    Returns:
        Status message
    Raises:
        HTTPException: If validation or saving fails
    """
    try:
        event_data = await request.json()  # Get JSON data from request
        await validate_input(event_data)  # Validate input
        sanitized_data = sanitize_fields(event_data)  # Sanitize fields
        event = SupplyChainEvent(**sanitized_data)  # Create event object
        with SessionLocal() as db:
            await save_to_db(db, event)  # Save to DB
        return {'message': 'Event created successfully!'}
    except ValidationError as e:
        logger.warning(f'Validation error: {e}')  # Log validation errors
        raise HTTPException(status_code=422, detail='Validation error')
    except Exception as e:
        logger.error(f'Unhandled exception: {e}')  # Log unexpected errors
        raise HTTPException(status_code=500, detail='Internal Server Error')

if __name__ == '__main__':
    # Example usage
    import uvicorn
    uvicorn.run(app, host='0.0.0.0', port=8000)  # Start FastAPI app