initial commit

.env.example

@@ -0,0 +1,30 @@
+# Application Configuration
+APP_NAME=LLM Analysis Quiz API
+ENVIRONMENT=development
+
+# Server Configuration
+HOST=0.0.0.0
+PORT=8000
+
+# Security
+API_SECRET=your-secret-key-here
+ALLOWED_ORIGINS=*
+
+# Logging
+LOG_LEVEL=INFO
+LOG_DIR=logs
+
+# Task Processing
+TASK_TIMEOUT=300
+MAX_RETRIES=3
+
+# External APIs
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+
+# Database (optional)
+DATABASE_URL=
+
+# Redis (optional)
+REDIS_URL=
+LOGTAIL_SOURCE_TOKEN=

.gitignore

@@ -0,0 +1,2 @@
+.env
+logs

README.md

@@ -0,0 +1,38 @@
+---
+title: LLM QUIZ ANALYSIS API
+emoji: 🚀
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+sdk_version: "0.0.1"
+app_file: app/main.py
+pinned: false
+---
+
+Check out the configuration reference at [https://huggingface.co/docs/hub/spaces-config-reference](https://huggingface.co/docs/hub/spaces-config-reference)
+
+## LLM Code Deployment API
+
+This Space provides a production-grade FastAPI backend for automated application generation and deployment, as described in the LLM Code Deployment project. It supports secure secret-based access, LLM-driven app generation, automated deployment to GitHub Pages, and evaluation callbacks—built with best practices for industry and Hugging Face Spaces Docker deployments.
+
+### Key Features
+
+- **POST `/handle-task`**: Receives and processes app brief requests, verifies secrets, and triggers app generation workflows.
+- **Dockerized Deployment**: Secure, reproducible builds using a custom Dockerfile following Hugging Face recommendations.
+- **Secrets Management**: Reads secrets via Hugging Face Spaces environment for maximum security (never hardcoded).
+- **GitHub Automation**: Automatically creates public repos, populates README and LICENSE, and enables GitHub Pages.
+
+### Usage
+
+1. Set up required Space secrets (secrets and tokens via the Spaces UI).
+2. Deploy or push your code to this Space.
+3. POST a task request (see `/handle-task` endpoint documentation).
+
+### Development
+
+See `requirements.txt` for dependencies.  
+Your FastAPI entry point should be specified in `app/main.py`.
+
+---
+
+For further configuration options, please visit the [Spaces Configuration Reference](https://huggingface.co/docs/hub/spaces-config-reference).

app/__init__.py

@@ -0,0 +1,6 @@
+"""
+LLM Analysis Quiz API Application Package
+"""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"

app/api/dependencies.py

@@ -0,0 +1,56 @@
+"""
+API Dependencies
+Reusable dependency injection functions
+"""
+
+from fastapi import Request, HTTPException, status
+
+from app.core.security import verify_secret
+from app.core.exceptions import AuthenticationError
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+async def get_request_body(request: Request) -> dict:
+    """
+    Extract and validate JSON body from request
+    
+    Args:
+        request: FastAPI Request object
+        
+    Returns:
+        dict: Parsed JSON body
+        
+    Raises:
+        HTTPException: If JSON parsing fails
+    """
+    try:
+        body = await request.json()
+        logger.debug(f"Request body received: {list(body.keys())}")
+        return body
+    except Exception as e:
+        logger.error(f"Failed to parse JSON: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid JSON format in request body"
+        )
+
+
+def verify_authentication(secret: str) -> bool:
+    """
+    Verify request authentication
+    
+    Args:
+        secret: Secret from request
+        
+    Returns:
+        bool: True if authenticated
+        
+    Raises:
+        AuthenticationError: If authentication fails
+    """
+    if not verify_secret(secret):
+        raise AuthenticationError("Invalid secret. Authentication failed.")
+    
+    return True

app/api/routes/__init__.py

@@ -0,0 +1,7 @@
+"""
+API Routes Package
+"""
+
+from app.api.routes import task, health
+
+__all__ = ["task", "health"]

app/api/routes/health.py

@@ -0,0 +1,42 @@
+"""
+Health Check Routes
+Endpoints for monitoring application health
+"""
+
+from fastapi import APIRouter
+
+from app.core.config import settings
+from app.core.logging import get_logger
+from app.models.response import HealthResponse
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=dict)
+async def root():
+    """
+    Root endpoint - basic health check
+    """
+    logger.debug("Root endpoint accessed")
+    return {
+        "status": "online",
+        "service": settings.APP_NAME,
+        "version": settings.APP_VERSION
+    }
+
+
+@router.get("/health", response_model=HealthResponse)
+async def health_check():
+    """
+    Detailed health check endpoint
+    """
+    logger.debug("Health check requested")
+    
+    return HealthResponse(
+        status="healthy",
+        environment=settings.ENVIRONMENT,
+        version=settings.APP_VERSION,
+        secret_configured=settings.is_secret_configured()
+    )

app/api/routes/task.py

@@ -0,0 +1,64 @@
+"""
+Task Processing Routes
+Main API endpoint for handling task requests
+"""
+
+from datetime import datetime
+from fastapi import APIRouter, Request, status
+
+from app.models.request import TaskRequest
+from app.models.response import TaskResponse
+from app.api.dependencies import verify_authentication
+from app.services.task_processor import TaskProcessor
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+task_processor = TaskProcessor()
+
+
+@router.post("/api/", response_model=TaskResponse, status_code=status.HTTP_200_OK)
+async def handle_task(request: Request):
+    """
+    Main API endpoint for handling task requests
+    
+    - Validates request format (HTTP 400 if invalid)
+    - Verifies secret (HTTP 403 if invalid)
+    - Processes task and returns results (HTTP 200 if successful)
+    """
+    start_time = datetime.now()
+    
+    logger.info("📥 Task request received")
+    
+    # Parse and validate request body with Pydantic
+    body = await request.json()
+    task_data = TaskRequest(**body)
+    
+    logger.info(f"✅ Request validated for: {task_data.email}")
+    
+    # Verify authentication
+    logger.info("🔐 Verifying authentication")
+    verify_authentication(task_data.secret)
+    logger.info("✅ Authentication successful")
+    
+    # Process the task
+    logger.info("🚀 Starting task execution")
+    result_data = await task_processor.process(task_data)
+    
+    # Calculate execution time
+    execution_time = (datetime.now() - start_time).total_seconds()
+    logger.info(f"⏱️  Task completed in {execution_time:.3f}s")
+    
+    # Prepare response
+    response = TaskResponse(
+        success=True,
+        message="Task completed successfully",
+        data=result_data,
+        email=task_data.email,
+        task_url=str(task_data.url),
+        execution_time=execution_time
+    )
+    
+    logger.info("✅ Response prepared successfully")
+    return response

app/core/config.py

@@ -0,0 +1,74 @@
+"""
+Application Configuration Management
+Centralizes all environment variables and settings
+"""
+
+import os
+from typing import List
+from pydantic_settings import BaseSettings
+from pydantic import  Field
+
+
+class Settings(BaseSettings):
+    """
+    Application settings loaded from environment variables
+    """
+    
+    # Application
+    APP_NAME: str = "LLM Analysis Quiz API"
+    APP_DESCRIPTION: str = "API endpoint for handling dynamic data analysis tasks"
+    APP_VERSION: str = "1.0.0"
+    ENVIRONMENT: str = Field(default="development", env="ENVIRONMENT")
+    
+    # Server
+    HOST: str = Field(default="0.0.0.0", env="HOST")
+    PORT: int = Field(default=8000, env="PORT")
+    
+    # Security
+    API_SECRET: str = Field(default="", env="API_SECRET")
+    ALLOWED_ORIGINS: List[str] = Field(
+        default=["*"],
+        env="ALLOWED_ORIGINS"
+    )
+    
+    # Logging
+    LOG_LEVEL: str = Field(default="INFO", env="LOG_LEVEL")
+    LOG_DIR: str = Field(default="logs", env="LOG_DIR")
+    # Cloud Logging
+    LOGTAIL_SOURCE_TOKEN: str = Field(default="", env="LOGTAIL_SOURCE_TOKEN")
+
+    
+    # Task Processing
+    TASK_TIMEOUT: int = Field(default=300, env="TASK_TIMEOUT")  # 5 minutes
+    MAX_RETRIES: int = Field(default=3, env="MAX_RETRIES")
+    
+    # External APIs (to be added as needed)
+    OPENAI_API_KEY: str = Field(default="", env="OPENAI_API_KEY")
+    ANTHROPIC_API_KEY: str = Field(default="", env="ANTHROPIC_API_KEY")
+    
+    # Database (for future use)
+    DATABASE_URL: str = Field(default="", env="DATABASE_URL")
+    
+    # Redis (for caching, future use)
+    REDIS_URL: str = Field(default="", env="REDIS_URL")
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        case_sensitive = True
+    
+    def is_secret_configured(self) -> bool:
+        """Check if API secret is configured"""
+        return bool(self.API_SECRET and self.API_SECRET.strip())
+    
+    def is_production(self) -> bool:
+        """Check if running in production"""
+        return self.ENVIRONMENT.lower() == "production"
+    
+    def is_development(self) -> bool:
+        """Check if running in development"""
+        return self.ENVIRONMENT.lower() == "development"
+
+
+# Global settings instance
+settings = Settings()

app/core/exceptions.py

@@ -0,0 +1,144 @@
+"""
+Custom Exceptions and Exception Handlers
+Centralizes error handling logic
+"""
+
+from datetime import datetime
+from typing import Any, Dict
+
+from fastapi import FastAPI, Request, status
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError, HTTPException
+
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class TaskProcessingError(Exception):
+    """Raised when task processing fails"""
+    pass
+
+
+class AuthenticationError(Exception):
+    """Raised when authentication fails"""
+    pass
+
+
+def create_error_response(
+    error_type: str,
+    message: str,
+    status_code: int,
+    details: Any = None
+) -> JSONResponse:
+    """
+    Create a standardized error response
+    
+    Args:
+        error_type: Type of error
+        message: Error message
+        status_code: HTTP status code
+        details: Optional additional details
+        
+    Returns:
+        JSONResponse: Formatted error response
+    """
+    content = {
+        "success": False,
+        "error": error_type,
+        "message": message,
+        "timestamp": datetime.now().isoformat()
+    }
+    
+    if details:
+        content["details"] = details
+    
+    return JSONResponse(
+        status_code=status_code,
+        content=content
+    )
+
+
+def register_exception_handlers(app: FastAPI):
+    """
+    Register all exception handlers with the FastAPI app
+    
+    Args:
+        app: FastAPI application instance
+    """
+    
+    @app.exception_handler(RequestValidationError)
+    async def validation_exception_handler(
+        request: Request,
+        exc: RequestValidationError
+    ):
+        """Handle Pydantic validation errors (HTTP 400)"""
+        error_details = exc.errors()
+        logger.error(f"❌ Validation Error: {error_details}")
+        
+        # Extract readable error messages
+        error_messages = []
+        for error in error_details:
+            field = " -> ".join(str(loc) for loc in error['loc'])
+            message = error['msg']
+            error_messages.append(f"{field}: {message}")
+        
+        return create_error_response(
+            error_type="ValidationError",
+            message="Invalid request format. " + "; ".join(error_messages),
+            status_code=status.HTTP_400_BAD_REQUEST,
+            details=error_details
+        )
+    
+    @app.exception_handler(HTTPException)
+    async def http_exception_handler(request: Request, exc: HTTPException):
+        """Handle HTTP exceptions"""
+        logger.error(f"❌ HTTP {exc.status_code}: {exc.detail}")
+        
+        return create_error_response(
+            error_type=f"HTTP{exc.status_code}",
+            message=exc.detail,
+            status_code=exc.status_code
+        )
+    
+    @app.exception_handler(TaskProcessingError)
+    async def task_processing_exception_handler(
+        request: Request,
+        exc: TaskProcessingError
+    ):
+        """Handle task processing errors"""
+        logger.error(f"❌ Task Processing Error: {str(exc)}", exc_info=True)
+        
+        return create_error_response(
+            error_type="TaskProcessingError",
+            message=str(exc),
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )
+    
+    @app.exception_handler(AuthenticationError)
+    async def authentication_exception_handler(
+        request: Request,
+        exc: AuthenticationError
+    ):
+        """Handle authentication errors"""
+        logger.warning(f"🚫 Authentication Error: {str(exc)}")
+        
+        return create_error_response(
+            error_type="AuthenticationError",
+            message=str(exc),
+            status_code=status.HTTP_403_FORBIDDEN
+        )
+    
+    @app.exception_handler(Exception)
+    async def general_exception_handler(request: Request, exc: Exception):
+        """Catch-all handler for unexpected exceptions"""
+        logger.error(
+            f"❌ Unhandled Exception: {str(exc)}",
+            exc_info=True
+        )
+        
+        return create_error_response(
+            error_type="InternalServerError",
+            message="An unexpected error occurred while processing your request",
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )

app/core/logging.py

@@ -0,0 +1,65 @@
+"""
+Production Logging with Better Stack (Logtail)
+Persistent cloud logging for evaluation and debugging
+"""
+
+import os
+import sys
+import logging
+from pathlib import Path
+
+from app.core.config import settings
+
+
+def setup_logging():
+    """
+    Configure logging with cloud persistence via Better Stack
+    """
+    
+    # Base formatter
+    formatter = logging.Formatter(
+        fmt='%(asctime)s | %(levelname)-8s | %(name)s | %(funcName)s:%(lineno)d | %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(getattr(logging, settings.LOG_LEVEL.upper()))
+    root_logger.handlers.clear()
+    
+    # Console handler (for HF Spaces logs viewer)
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+    
+    # Better Stack handler for persistent logging
+    if settings.LOGTAIL_SOURCE_TOKEN:
+        try:
+            from logtail import LogtailHandler
+            
+            logtail_handler = LogtailHandler(source_token=settings.LOGTAIL_SOURCE_TOKEN)
+            logtail_handler.setLevel(logging.INFO)
+            logtail_handler.setFormatter(formatter)
+            root_logger.addHandler(logtail_handler)
+            
+            logger = logging.getLogger(__name__)
+            logger.info("✅ Better Stack logging enabled - logs will persist")
+        except Exception as e:
+            logger = logging.getLogger(__name__)
+            logger.warning(f"⚠️  Failed to initialize Better Stack: {e}")
+    else:
+        logger = logging.getLogger(__name__)
+        logger.warning("⚠️  LOGTAIL_SOURCE_TOKEN not set - logs will not persist")
+    
+    # Reduce third-party noise
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    
+    logger = logging.getLogger(__name__)
+    logger.info("Logging initialized for %s", settings.ENVIRONMENT)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance"""
+    return logging.getLogger(name)

app/core/security.py

@@ -0,0 +1,57 @@
+"""
+Security Utilities
+Handles authentication and authorization
+"""
+
+from app.core.config import settings
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def verify_secret(provided_secret: str) -> bool:
+    """
+    Verify the provided secret against environment configuration
+    
+    Args:
+        provided_secret: Secret from request
+        
+    Returns:
+        bool: True if secret matches, False otherwise
+    """
+    if not settings.is_secret_configured():
+        logger.error("⚠️  API_SECRET not configured in environment")
+        return False
+    
+    is_valid = provided_secret == settings.API_SECRET
+    
+    if is_valid:
+        logger.info("✅ Secret verification successful")
+    else:
+        logger.warning("🚫 Secret verification failed")
+        logger.debug(
+            f"Expected length: {len(settings.API_SECRET)}, "
+            f"Got length: {len(provided_secret)}"
+        )
+    
+    return is_valid
+
+
+def mask_secret(secret: str, visible_chars: int = 4) -> str:
+    """
+    Mask secret for logging purposes
+    
+    Args:
+        secret: Secret to mask
+        visible_chars: Number of characters to show at the end
+        
+    Returns:
+        str: Masked secret
+    """
+    if not secret:
+        return ""
+    
+    if len(secret) <= visible_chars:
+        return "*" * len(secret)
+    
+    return "*" * (len(secret) - visible_chars) + secret[-visible_chars:]

app/main.py

@@ -0,0 +1,99 @@
+"""
+Main FastAPI Application Entry Point
+Initializes the FastAPI app with all configurations, middleware, and routes
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+
+from app.core.config import settings
+from app.core.logging import setup_logging, get_logger
+from app.core.exceptions import register_exception_handlers
+from app.middleware.logging import LoggingMiddleware
+from app.api.routes import task, health
+
+
+# Initialize logger
+logger = get_logger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Application lifespan manager for startup and shutdown events
+    """
+    # Startup
+    logger.info("=" * 80)
+    logger.info("🚀 Starting LLM Analysis Quiz API")
+    logger.info(f"Environment: {settings.ENVIRONMENT}")
+    logger.info(f"Version: {settings.APP_VERSION}")
+    logger.info(f"Secret configured: {settings.is_secret_configured()}")
+    logger.info("=" * 80)
+    
+    if not settings.is_secret_configured():
+        logger.warning("⚠️  WARNING: API_SECRET not configured!")
+    
+    yield
+    
+    # Shutdown
+    logger.info("=" * 80)
+    logger.info("🛑 Shutting down LLM Analysis Quiz API")
+    logger.info("=" * 80)
+
+
+
+def create_application() -> FastAPI:
+    """
+    Application factory pattern for creating FastAPI instance
+    """
+    app = FastAPI(
+        title=settings.APP_NAME,
+        description=settings.APP_DESCRIPTION,
+        version=settings.APP_VERSION,
+        lifespan=lifespan,
+        docs_url="/docs" if settings.ENVIRONMENT == "development" else None,
+        redoc_url="/redoc" if settings.ENVIRONMENT == "development" else None,
+    )
+    
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=settings.ALLOWED_ORIGINS,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    # Add custom middleware
+    app.add_middleware(LoggingMiddleware)
+    
+    # Register exception handlers
+    register_exception_handlers(app)
+    
+    # Include routers
+    app.include_router(health.router, tags=["Health"])
+    app.include_router(task.router, tags=["Tasks"])
+    
+    return app
+
+
+# Initialize logging
+setup_logging()
+
+# Create app instance
+app = create_application()
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    logger.info(f"Starting server on {settings.HOST}:{settings.PORT}")
+    
+    uvicorn.run(
+        "app.main:app",
+        host=settings.HOST,
+        port=settings.PORT,
+        reload=settings.ENVIRONMENT == "development",
+        log_level="info"
+    )

app/middleware/logging.py

@@ -0,0 +1,51 @@
+"""
+Logging Middleware
+Logs all incoming requests and responses
+"""
+
+import time
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from app.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class LoggingMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware to log all HTTP requests and responses
+    """
+    
+    async def dispatch(self, request: Request, call_next):
+        """
+        Process each request and log details
+        """
+        start_time = time.time()
+        
+        # Log incoming request
+        logger.info(f"📥 {request.method} {request.url.path}")
+        logger.debug(f"Client: {request.client.host if request.client else 'Unknown'}")
+        
+        # Process request
+        try:
+            response = await call_next(request)
+            
+            # Calculate execution time
+            execution_time = time.time() - start_time
+            
+            # Log response
+            logger.info(
+                f"📤 Response: {response.status_code} | "
+                f"Time: {execution_time:.3f}s"
+            )
+            
+            return response
+        
+        except Exception as e:
+            execution_time = time.time() - start_time
+            logger.error(
+                f"❌ Request failed after {execution_time:.3f}s: {str(e)}",
+                exc_info=True
+            )
+            raise

app/models/request.py

@@ -0,0 +1,58 @@
+"""
+Request Models (Pydantic Schemas)
+Defines the structure of incoming requests
+"""
+
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field, EmailStr, HttpUrl, validator
+
+
+class TaskRequest(BaseModel):
+    """
+    Schema for task request validation
+    """
+    email: EmailStr = Field(
+        ...,
+        description="Student email ID",
+        examples=["[email protected]"]
+    )
+    
+    secret: str = Field(
+        ...,
+        min_length=1,
+        description="Student-provided secret for authentication",
+        examples=["my-secret-key-123"]
+    )
+    
+    url: HttpUrl = Field(
+        ...,
+        description="Unique task URL containing the quiz question",
+        examples=["https://example.com/quiz-834"]
+    )
+    
+    task_description: Optional[str] = Field(
+        None,
+        description="Optional description of the task to perform"
+    )
+    
+    additional_params: Optional[Dict[str, Any]] = Field(
+        None,
+        description="Optional additional parameters for task execution"
+    )
+    
+    @validator('secret')
+    def secret_not_empty(cls, v):
+        """Ensure secret is not just whitespace"""
+        if not v or not v.strip():
+            raise ValueError('Secret cannot be empty or whitespace')
+        return v.strip()
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "email": "[email protected]",
+                "secret": "your-secret-key",
+                "url": "https://example.com/quiz-834",
+                "task_description": "Scrape the webpage and analyze data"
+            }
+        }

app/models/response.py

@@ -0,0 +1,74 @@
+"""
+Response Models (Pydantic Schemas)
+Defines the structure of API responses
+"""
+
+from typing import Optional, Dict, Any
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class TaskResponse(BaseModel):
+    """
+    Schema for successful task responses
+    """
+    success: bool = Field(
+        ...,
+        description="Whether the task completed successfully"
+    )
+    
+    message: str = Field(
+        ...,
+        description="Status message"
+    )
+    
+    data: Optional[Dict[str, Any]] = Field(
+        None,
+        description="Task result data"
+    )
+    
+    email: Optional[str] = Field(
+        None,
+        description="Email from request"
+    )
+    
+    task_url: Optional[str] = Field(
+        None,
+        description="Task URL processed"
+    )
+    
+    execution_time: Optional[float] = Field(
+        None,
+        description="Execution time in seconds"
+    )
+    
+    timestamp: str = Field(
+        default_factory=lambda: datetime.now().isoformat(),
+        description="Response timestamp"
+    )
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "success": True,
+                "message": "Task completed successfully",
+                "data": {"result": "Analysis complete"},
+                "email": "[email protected]",
+                "task_url": "https://example.com/quiz-834",
+                "execution_time": 2.34,
+                "timestamp": "2025-11-27T23:48:00"
+            }
+        }
+
+
+class HealthResponse(BaseModel):
+    """
+    Schema for health check responses
+    """
+    status: str = Field(..., description="Service status")
+    timestamp: str = Field(
+        default_factory=lambda: datetime.now().isoformat()
+    )
+    environment: Optional[str] = Field(None)
+    version: Optional[str] = Field(None)
+    secret_configured: Optional[bool] = Field(None)

app/services/task_processor.py

@@ -0,0 +1,56 @@
+"""
+Task Processing Service
+Business logic for processing tasks
+"""
+
+from typing import Dict, Any
+
+from app.models.request import TaskRequest
+from app.core.logging import get_logger
+from app.core.exceptions import TaskProcessingError
+
+logger = get_logger(__name__)
+
+
+class TaskProcessor:
+    """
+    Service class for processing tasks
+    Handles the core business logic
+    """
+    
+    def __init__(self):
+        logger.debug("TaskProcessor initialized")
+    
+    async def process(self, task_data: TaskRequest) -> Dict[str, Any]:
+        """
+        Process a task based on the provided data
+        
+        Args:
+            task_data: Validated task request
+            
+        Returns:
+            Dict containing task results
+            
+        Raises:
+            TaskProcessingError: If processing fails
+        """
+        logger.info(f"Processing task for: {task_data.email}")
+        logger.info(f"Task URL: {task_data.url}")
+        
+        try:
+            # TODO: Implement actual task processing logic
+            # This will integrate with orchestrator and various modules
+            
+            result = {
+                "status": "processed",
+                "task_url": str(task_data.url),
+                "message": "Task processing logic to be implemented",
+                "email": task_data.email
+            }
+            
+            logger.info("✅ Task processed successfully")
+            return result
+        
+        except Exception as e:
+            logger.error(f"❌ Task processing failed: {str(e)}", exc_info=True)
+            raise TaskProcessingError(f"Failed to process task: {str(e)}")

dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.11-slim
+
+RUN useradd -m -u 1000 user
+
+WORKDIR /home/user/app
+
+
+# Install dependencies
+COPY --chown=user ./requirements.txt requirements.txt
+
+RUN pip install -r requirements.txt
+
+COPY --chown=user . .
+
+USER user
+ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
+
+# Expose port
+EXPOSE 7860
+
+# Run with production settings
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

requirements.txt

@@ -0,0 +1,18 @@
+# Core Framework
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+pydantic
+pydantic-settings
+pydantic[email]
+python-dotenv==1.0.0
+logtail-python
+
+# HTTP Clients
+httpx==0.26.0
+requests==2.31.0
+
+# Data Processing
+# pandas==2.2.0
+# numpy==1.26.3
+
+# Add more as you build modules