Wegent Backend API Architecture Analysis

@asynccontextmanager
async def lifespan(app: FastAPI):
    # STARTUP: Initialize database, YAML configs, background jobs, schedulers, WebSocket, event bus
    yield
    # SHUTDOWN: Graceful cleanup with timeout, cancel active streams

app = create_socketio_asgi_app()  # Combines Socket.IO server with FastAPI

# Database session dependency
def get_db() -> Generator[Session, None, None]:
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# OpenTelemetry context dependencies
def with_task_telemetry(task_id: int = Path(...)) -> int:
    """Sets task context for distributed tracing"""
    
def with_task_subtask_telemetry(
    task_id: int = Path(...), 
    subtask_id: Optional[int] = None
) -> tuple:
    """Sets both task and subtask context"""

@router.get("/{task_id}")
def get_task(
    task_id: int = Depends(with_task_telemetry),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    # Dependencies are injected automatically
    pass

# Automatic context management
@auto_task_context(TaskJoinPayload)
async def on_task_join(self, sid: str, data: dict) -> dict:
    # Payload is automatically validated and typed
    pass

# Telemetry tracing
@trace_websocket_event(exclude_events={"connect"}, extract_event_data=True)
async def trigger_event(self, event: str, sid: str, *args):
    # Automatic OpenTelemetry span creation
    pass

# Core authentication
def authenticate_user(db, username, password) -> Union[User, None]
def create_access_token(data: Dict[str, Any], expires_delta: Optional[int]) -> str
def verify_token(token: str) -> Dict[str, Any]

# Dependency injection
def get_current_user(token: str = Depends(oauth2_scheme)) -> User
def get_admin_user(current_user: User = Depends(get_current_user)) -> User
def get_auth_context(...) -> AuthContext  # Flexible API key auth
def get_current_user_flexible(...) -> User

# Role-based access control
@router.delete("/{team_id}")
def delete_team(
    team_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    # Check ownership within service layer
    team_kinds_service.delete_with_user(db, team_id, current_user.id)

# Admin-only endpoints
@router.get("/admin/users")
def list_all_users(
    current_user: User = Depends(get_admin_user)  # Validates admin role
):
    pass

# Common helpers (app/api/endpoints/kind/common.py)
KIND_SCHEMA_MAP = {
    "Ghost": Ghost,
    "Model": Model,
    "Shell": Shell,
    "Bot": Bot,
    "Team": Team,
    # ... etc
}

# Validation
kind = validate_resource_type(kinds)  # "teams" -> "Team"

# Formatting
return format_single_resource(kind, resource)
return format_resource_list(kind, resources)

# Validation & preparation
validated_resource = validate_and_prepare_resource(kind, resource, namespace, name)

# app/api/endpoints/adapter/teams.py
@router.get("", response_model=TeamListResponse)
def list_teams(
    page: int = Query(1, ge=1),
    limit: int = Query(10, ge=1, le=100),
    scope: str = Query("all"),
    db: Session = Depends(get_db),
    current_user: User = Depends(security.get_current_user),
):
    # Uses adapter service that works with Kind model
    items = team_kinds_service.get_user_teams(
        db=db, user_id=current_user.id, skip=skip, limit=limit, scope=scope
    )
    return {"total": total, "items": items}

@router.post("", response_model=TeamInDB, status_code=status.HTTP_201_CREATED)
def create_team(
    team_create: TeamCreate,
    current_user: User = Depends(security.get_current_user),
    db: Session = Depends(get_db),
):
    # Adapter service handles Kind model creation
    return team_kinds_service.create_with_user(
        db=db, obj_in=team_create, user_id=current_user.id
    )

# app/services/adapters/team_kinds.py
class TeamKindsService:
    def get_user_teams(self, db, user_id, skip, limit, scope):
        # Query Kind table with kind="Team"
        # Transform to Team schema
        pass
    
    def create_with_user(self, db, obj_in, user_id, group_name=None):
        # Convert TeamCreate to Kind model
        # Set ownership, namespace
        # Save to kinds table
        pass

class Settings(BaseSettings):
    # Project
    PROJECT_NAME: str = "Task Manager Backend"
    VERSION: str = "1.0.0"
    API_PREFIX: str = "/api"
    
    # Database
    DATABASE_URL: str = "mysql+asyncmy://..."
    DB_AUTO_MIGRATE: bool = True
    
    # Authentication
    SECRET_KEY: str = "secret-key"
    ALGORITHM: str = "HS256"
    ACCESS_TOKEN_EXPIRE_MINUTES: int = 7 * 24 * 60
    
    # External Services
    CHAT_SHELL_MODE: str = "http"  # or "package"
    CHAT_SHELL_URL: str = "http://localhost:8100"
    
    # Scheduler
    SCHEDULER_BACKEND: str = "celery"  # or "apscheduler", "xxljob"
    
    # Feature Flags
    CHAT_MCP_ENABLED: bool = False
    MEMORY_ENABLED: bool = False
    WEB_SEARCH_ENABLED: bool = False

# app/core/exceptions.py
class NotFoundException(HTTPException):
    def __init__(self, detail: str):
        super().__init__(status_code=404, detail=detail)

class ConflictException(HTTPException):
    def __init__(self, detail: str):
        super().__init__(status_code=409, detail=detail)

class ValidationException(HTTPException):
    def __init__(self, detail: str):
        super().__init__(status_code=400, detail=detail)

class CustomHTTPException(HTTPException):
    def __init__(self, status_code: int, detail: str, error_code: int = None):
        super().__init__(status_code=status_code, detail=detail)
        self.error_code = error_code

# Registered in create_app()
app.add_exception_handler(CustomHTTPException, http_exception_handler)
app.add_exception_handler(RequestValidationError, validation_exception_handler)
app.add_exception_handler(Exception, python_exception_handler)