aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/backend/api/auth/router.py

@@ -0,0 +1,64 @@
+"""Authentication API routes."""
+
+from app.components.backend.api.deps import get_async_db
+from app.core.security import create_access_token, verify_password
+from app.models.user import UserCreate, UserResponse
+from app.services.auth.auth_service import get_current_user_from_token
+from app.services.auth.user_service import UserService
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+router = APIRouter(prefix="/auth", tags=["authentication"])
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/v1/auth/token")
+
+
+@router.post("/register", response_model=UserResponse)
+async def register(user_data: UserCreate, db: AsyncSession = Depends(get_async_db)):
+    """Register a new user."""
+    user_service = UserService(db)
+
+    # Check if user already exists
+    existing_user = await user_service.get_user_by_email(user_data.email)
+    if existing_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Email already registered"
+        )
+
+    # Create new user
+    user = await user_service.create_user(user_data)
+    return UserResponse.model_validate(user)
+
+
+@router.post("/token")
+async def login(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+    db: AsyncSession = Depends(get_async_db),
+):
+    """Login and get access token."""
+    user_service = UserService(db)
+
+    # Get user by email (username field in OAuth2 form)
+    user = await user_service.get_user_by_email(form_data.username)
+
+    if not user or not verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    # Create access token
+    access_token = create_access_token(data={"sub": user.email})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_async_db),
+):
+    """Get current authenticated user."""
+    user = await get_current_user_from_token(token, db)
+    return UserResponse.model_validate(user)

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/backend/api/deps.py

@@ -0,0 +1,58 @@
+"""FastAPI dependencies for the backend API."""
+
+from collections.abc import AsyncGenerator, Generator
+
+from app.core.db import AsyncSessionLocal, SessionLocal
+from sqlmodel import Session
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+
+def get_db() -> Generator[Session, None, None]:
+    """
+    Database dependency that provides a database session.
+
+    This dependency is used in FastAPI route functions to get access to
+    the database. It automatically handles session lifecycle - creating,
+    yielding, and closing the session properly.
+
+    Usage:
+        @router.get("/example")
+        def example_endpoint(db: Session = Depends(get_db)):
+            # Use db for database operations
+            pass
+
+    Yields:
+        Session: SQLModel database session
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+async def get_async_db() -> AsyncGenerator[AsyncSession, None]:
+    """
+    Async database dependency that provides an async database session.
+
+    This dependency is used in async FastAPI route functions to get access to
+    the database with non-blocking I/O operations. It automatically handles
+    session lifecycle - creating, yielding, committing and closing the session properly.
+
+    Usage:
+        @router.get("/example")
+        async def example_endpoint(db: AsyncSession = Depends(get_async_db)):
+            # Use db for async database operations with await
+            result = await db.exec(select(MyModel))
+            return result.first()
+
+    Yields:
+        AsyncSession: SQLModel async database session
+    """
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/backend/api/health.py.jinja

@@ -0,0 +1,163 @@
+from typing import Any
+
+from app.services.system import (
+    DetailedHealthResponse,
+    HealthResponse,
+    get_system_status,
+)
+from fastapi import APIRouter, HTTPException
+from starlette import status
+
+router = APIRouter()
+
+
+@router.get("/", response_model=HealthResponse)
+async def health_check() -> HealthResponse:
+    """
+    Quick health check endpoint.
+
+    Returns basic healthy/unhealthy status for load balancers and monitoring.
+    """
+    try:
+        system_status = await get_system_status()
+        return HealthResponse(
+            healthy=system_status.overall_healthy,
+            status="healthy" if system_status.overall_healthy else "unhealthy",
+            components=system_status.components,
+            timestamp=system_status.timestamp.isoformat(),
+        )
+    except Exception:
+        # If health checks fail completely, consider unhealthy
+        return HealthResponse(
+            healthy=False,
+            status="unhealthy",
+            components={},
+            timestamp="",
+        )
+
+
+@router.get("/detailed", response_model=DetailedHealthResponse)
+async def detailed_health() -> DetailedHealthResponse:
+    """
+    Detailed health check with component information.
+
+    Returns comprehensive system status including individual component health,
+    system metrics, and diagnostic information.
+    """
+    try:
+        system_status = await get_system_status()
+
+        # Always return 200 OK - service is available even if components are unhealthy
+        return DetailedHealthResponse(
+            healthy=system_status.overall_healthy,
+            status="healthy" if system_status.overall_healthy else "unhealthy",
+            service="{{ project_name }}",
+            version="0.1.0",
+            components=system_status.components,
+            system_info=system_status.system_info,
+            timestamp=system_status.timestamp.isoformat(),
+            healthy_components=system_status.healthy_components,
+            unhealthy_components=system_status.unhealthy_components,
+            health_percentage=system_status.health_percentage,
+            # Service-specific information
+            has_services=system_status.has_services,
+            service_names=system_status.service_names,
+            healthy_services=system_status.healthy_services,
+            unhealthy_services=system_status.unhealthy_services,
+        )
+
+    except HTTPException:
+        # Re-raise HTTP exceptions from unexpected errors
+        raise
+    except Exception as e:
+        # Handle unexpected errors
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail={
+                "message": "Health check failed",
+                "error": str(e),
+                "status": "unhealthy",
+            },
+        )
+
+
+@router.get("/dashboard")
+async def system_dashboard() -> dict[str, Any]:
+    """
+    System dashboard endpoint optimized for frontend consumption.
+
+    Returns system status with additional dashboard metadata like
+    alert counts, trend data, and formatted display information.
+    """
+    try:
+        system_status = await get_system_status()
+
+        # TODO: Implement alert tracking when alert management is enhanced
+        recent_alerts = 0
+
+        return {
+            "status": "healthy" if system_status.overall_healthy else "unhealthy",
+            "service": "{{ project_name }}",
+            "version": "0.1.0",
+            "dashboard_data": {
+                "overall_status": {
+                    "healthy": system_status.overall_healthy,
+                    "percentage": system_status.health_percentage,
+                    "status_text": (
+                        "System Healthy"
+                        if system_status.overall_healthy
+                        else "Issues Detected"
+                    ),
+                },
+                "components": {
+                    name: {
+                        "name": name,
+                        "healthy": component.healthy,
+                        "message": component.message,
+                        "response_time_ms": component.response_time_ms,
+                        "metadata": component.metadata,
+                    }
+                    for name, component in system_status.components.items()
+                },
+                "summary": {
+                    "total_components": len(system_status.components),
+                    "healthy_components": len(system_status.healthy_components),
+                    "unhealthy_components": len(system_status.unhealthy_components),
+                    "recent_alerts": recent_alerts,
+                    # Service summary information
+                    "has_services": system_status.has_services,
+                    "total_services": len(system_status.service_names),
+                    "healthy_services": len(system_status.healthy_services),
+                    "unhealthy_services": len(system_status.unhealthy_services),
+                },
+                # Services section for frontend consumption
+                "services": {
+                    "enabled": system_status.has_services,
+                    "services": {
+                        name: {
+                            "name": name,
+                            "healthy": service.healthy,
+                            "message": service.message,
+                            "response_time_ms": service.response_time_ms,
+                            "metadata": service.metadata,
+                        }
+                        for name, service in (
+                            system_status.services_status.sub_components.items()
+                            if system_status.services_status
+                            else {}
+                        ).items()
+                    }
+                    if system_status.has_services
+                    else {},
+                },
+                "system_info": system_status.system_info,
+                "timestamp": system_status.timestamp.isoformat(),
+                "last_updated": system_status.timestamp.strftime("%H:%M:%S"),
+            },
+        }
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail={"message": "Dashboard data unavailable", "error": str(e)},
+        )

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/backend/api/models.py.jinja

@@ -0,0 +1,280 @@
+"""
+API models for{%- if include_worker %} background tasks{%- endif %}{%- if include_worker and scheduler_backend != "memory" %} and{%- endif %}{%- if scheduler_backend != "memory" %} scheduled tasks{%- endif %} and responses.
+
+This module contains all Pydantic models used by the API layer for
+task management, status tracking, and response formatting.
+"""
+
+{%- if include_worker or scheduler_backend != "memory" %}
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+{%- endif %}
+
+{%- if include_worker %}
+from app.components.worker.constants import LoadTestTypes
+{%- endif %}
+
+{%- if scheduler_backend != "memory" %}
+from app.services.scheduler.models import ScheduledTask, TaskStatistics
+{%- endif %}
+
+{%- if include_worker %}
+
+class TaskRequest(BaseModel):
+    """Request model for enqueueing a background task."""
+
+    task_name: str = Field(..., description="Name of the task function to execute")
+    queue_type: str = Field(
+        "system", description="Functional queue type: media or system"
+    )
+    args: list[Any] = Field(
+        default_factory=list, description="Positional arguments for the task"
+    )
+    task_kwargs: dict[str, Any] = Field(
+        default_factory=dict, description="Keyword arguments for the task"
+    )
+    delay_seconds: int | None = Field(
+        None, description="Delay task execution by this many seconds"
+    )
+
+
+class TaskResponse(BaseModel):
+    """Response model for task enqueue operations."""
+
+    task_id: str
+    task_name: str
+    queue_type: str
+    queued_at: datetime
+    estimated_start: datetime | None = None
+    message: str
+
+
+class TaskListResponse(BaseModel):
+    """Response model for listing available tasks."""
+
+    available_tasks: list[str]
+    total_count: int
+    queues: dict[str, list[str]]
+
+
+class TaskStatusResponse(BaseModel):
+    """Response model for task status checks."""
+
+    task_id: str
+    status: str = Field(
+        ...,
+        description="Task status: queued, in_progress, complete, failed, unknown",
+    )
+    enqueue_time: datetime | None = Field(
+        None, description="When the task was enqueued"
+    )
+    start_time: datetime | None = Field(
+        None, description="When the task started processing"
+    )
+    finish_time: datetime | None = Field(None, description="When the task completed")
+    result_available: bool = Field(
+        False, description="Whether task result is available"
+    )
+    error: str | None = Field(None, description="Error message if task failed")
+
+
+class TaskResultResponse(BaseModel):
+    """Response model for completed task results."""
+
+    task_id: str
+    status: str = Field(..., description="Task completion status")
+    result: Any = Field(..., description="The actual task result data")
+    enqueue_time: datetime | None = Field(
+        None, description="When the task was enqueued"
+    )
+    start_time: datetime | None = Field(
+        None, description="When the task started processing"
+    )
+    finish_time: datetime | None = Field(None, description="When the task completed")
+
+
+class LoadTestRequest(BaseModel):
+    """Request model for orchestrating load tests that measure queue throughput."""
+
+    num_tasks: int = Field(
+        100,
+        description="Number of tasks to spawn for the load test",
+        ge=10,
+        le=10000
+    )
+    task_type: LoadTestTypes = Field(
+        LoadTestTypes.CPU_INTENSIVE,
+        description="Type of worker task to spawn for load testing",
+    )
+    batch_size: int = Field(
+        10,
+        description="How many tasks to send concurrently per batch",
+        ge=1,
+        le=100
+    )
+    delay_ms: int = Field(
+        0,
+        description="Delay between batches in milliseconds",
+        ge=0,
+        le=5000
+    )
+    target_queue: str = Field(
+        "load_test",
+        description="Which queue to test (system, media, or load_test)",
+        pattern="^(system|media|load_test)$"
+    )
+
+    class Config:
+        schema_extra = {
+            "examples": [
+                {
+                    "description": (
+                        "Quick CPU load test - fibonacci calculations and operations"
+                    ),
+                    "num_tasks": 50,
+                    "task_type": "cpu_intensive",
+                    "batch_size": 10,
+                    "delay_ms": 0,
+                    "target_queue": "system",
+                    "expected_work": (
+                        "Computational: fibonacci, prime checking, math operations"
+                    ),
+                    "expected_metrics": [
+                        "fibonacci_result",
+                        "math_operations_sum",
+                        "operations_per_ms",
+                    ]
+                },
+                {
+                    "description": (
+                        "I/O stress test - async operations and concurrent handling"
+                    ),
+                    "num_tasks": 200,
+                    "task_type": "io_simulation",
+                    "batch_size": 20,
+                    "delay_ms": 50,
+                    "target_queue": "system",
+                    "expected_work": (
+                        "Async I/O: network delays, concurrent operations, files"
+                    ),
+                    "expected_metrics": [
+                        "concurrent_operations",
+                        "io_efficiency_percent",
+                        "concurrency_benefit",
+                    ]
+                },
+                {
+                    "description": (
+                        "Memory allocation test - data structures and GC pressure"
+                    ),
+                    "num_tasks": 500,
+                    "task_type": "memory_operations",
+                    "batch_size": 25,
+                    "delay_ms": 0,
+                    "target_queue": "media",
+                    "expected_work": (
+                        "Memory: allocation patterns, data manipulation, cleanup"
+                    ),
+                    "expected_metrics": [
+                        "estimated_peak_memory_mb",
+                        "memory_throughput_mb_per_sec",
+                        "memory_operations_count",
+                    ]
+                },
+                {
+                    "description": (
+                        "Failure resilience test - ~20% random failures for errors"
+                    ),
+                    "num_tasks": 100,
+                    "task_type": "test_task_failure",
+                    "batch_size": 15,
+                    "delay_ms": 0,
+                    "target_queue": "system",
+                    "expected_work": (
+                        "Failure testing: random errors, recovery patterns, resilience"
+                    ),
+                    "expected_metrics": [
+                        "failure_roll",
+                        "failure_threshold",
+                        "would_have_failed",
+                    ]
+                }
+            ]
+        }
+
+
+class LoadTestStatus(BaseModel):
+    """Status model for monitoring active load tests."""
+
+    test_id: str = Field(..., description="Unique load test identifier")
+    status: str = Field(..., description="Test status: running, completed, failed")
+    tasks_sent: int = Field(..., description="Number of tasks sent to queue")
+    tasks_completed: int = Field(..., description="Number of tasks completed")
+    tasks_failed: int = Field(0, description="Number of tasks that failed")
+    elapsed_seconds: float = Field(..., description="Time elapsed since test start")
+    current_throughput: float = Field(..., description="Current tasks per second")
+    estimated_completion: datetime | None = Field(
+        None, description="Estimated completion time"
+    )
+    queue_depth: int = Field(0, description="Current queue depth")
+
+
+class LoadTestResults(BaseModel):
+    """Final results model for completed load tests."""
+
+    test_id: str = Field(..., description="Unique load test identifier")
+    status: str = Field(..., description="Final test status")
+    configuration: LoadTestRequest = Field(..., description="Test configuration used")
+
+    # Task metrics
+    tasks_sent: int = Field(..., description="Total tasks sent")
+    tasks_completed: int = Field(..., description="Total tasks completed")
+    tasks_failed: int = Field(..., description="Total tasks failed")
+
+    # Timing metrics
+    start_time: datetime = Field(..., description="Test start time")
+    end_time: datetime | None = Field(None, description="Test end time")
+    total_duration_seconds: float = Field(..., description="Total test duration")
+
+    # Performance metrics
+    overall_throughput: float = Field(..., description="Overall tasks per second")
+    peak_throughput: float = Field(..., description="Peak throughput achieved")
+    failure_rate: float = Field(..., description="Percentage of tasks that failed")
+
+    # Queue metrics
+    final_queue_metrics: dict[str, Any] = Field(
+        ..., description="Final arq queue health data"
+    )
+
+    # Summary
+    performance_summary: str = Field(
+        ..., description="Human readable performance summary"
+    )
+{%- endif %}
+
+{%- if scheduler_backend != "memory" %}
+
+# ============================================================================
+# SCHEDULED TASK API MODELS
+# ============================================================================
+
+class ScheduledTaskListResponse(BaseModel):
+    """Response model for listing scheduled tasks."""
+
+    tasks: list[ScheduledTask] = Field(..., description="List of scheduled tasks")
+    total_count: int = Field(..., description="Total number of scheduled tasks")
+
+
+class ScheduledTaskDetailResponse(BaseModel):
+    """Response model for scheduled task details."""
+
+    task: ScheduledTask = Field(..., description="Detailed scheduled task information")
+
+
+class ScheduledTaskStatisticsResponse(BaseModel):
+    """Response model for scheduled task statistics."""
+
+    statistics: TaskStatistics = Field(..., description="Task statistics summary")
+{%- endif %}

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/backend/api/routing.py.jinja

@@ -0,0 +1,32 @@
+from fastapi import FastAPI
+
+from app.components.backend.api import health
+{%- if include_worker %}
+from app.components.backend.api import worker
+{%- endif %}
+{%- if scheduler_backend != "memory" %}
+from app.components.backend.api import scheduler
+{%- endif %}
+{%- if include_auth %}
+from app.components.backend.api.auth.router import router as auth_router
+{%- endif %}
+{%- if include_ai %}
+from app.components.backend.api.ai.router import router as ai_router
+{%- endif %}
+
+
+def include_routers(app: FastAPI) -> None:
+    """Include all API routers in the FastAPI app"""
+    app.include_router(health.router, prefix="/health", tags=["health"])
+    {%- if include_worker %}
+    app.include_router(worker.router, prefix="/api/v1", tags=["worker"])
+    {%- endif %}
+    {%- if scheduler_backend != "memory" %}
+    app.include_router(scheduler.router, prefix="/api/v1", tags=["scheduler"])
+    {%- endif %}
+    {%- if include_auth %}
+    app.include_router(auth_router, prefix="/api/v1")
+    {%- endif %}
+    {%- if include_ai %}
+    app.include_router(ai_router)
+    {%- endif %}