aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/pyproject.toml.j2

@@ -0,0 +1,131 @@
+[project]
+name = "{{ cookiecutter.project_slug }}"
+version = "{{ cookiecutter.version }}"
+description = "{{ cookiecutter.project_description }}"
+readme = "README.md"
+requires-python = ">={{ cookiecutter.python_version }}"
+authors = [
+    {name = "{{ cookiecutter.author_name }}", email = "{{ cookiecutter.author_email }}"}
+]
+
+dependencies = [
+    "fastapi==0.116.1",
+    "flet[all]==0.28.3",
+    "uvicorn==0.35.0",
+    "structlog==25.4.0",
+    "pydantic-settings==2.10.1",
+    "typer==0.16.0",
+    # Pin click to avoid yanked versions (typer dependency)
+    "click==8.2.1",
+    # Rich CLI formatting
+    "rich==14.1.0",
+    # HTTP client for CLI API calls
+    "httpx==0.28.1",
+    # System monitoring
+    "psutil==7.0.0",
+{%- if cookiecutter.include_scheduler == "yes" %}
+    "apscheduler==3.10.4",
+{%- endif %}
+{%- if cookiecutter.include_redis == "yes" %}
+    "redis==5.0.8",
+{%- endif %}
+{%- if cookiecutter.include_worker == "yes" %}
+    "arq==0.25.0",
+{%- endif %}
+{%- if cookiecutter.include_database == "yes" %}
+    "sqlmodel>=0.0.14",
+    "sqlalchemy>=2.0.0",
+    "aiosqlite>=0.19.0",
+    "greenlet>=1.1.0",
+{%- endif %}
+{%- if cookiecutter.include_cache == "yes" %}
+    "redis[hiredis]==5.0.8",
+{%- endif %}
+{%- if cookiecutter.include_auth == "yes" %}
+    "python-jose[cryptography]==3.3.0",
+    "passlib[bcrypt]==1.7.4",
+    "bcrypt<5.0.0",  # Pin to 4.x due to passlib compatibility
+    "python-multipart==0.0.9",
+    "email-validator==2.2.0",
+    "alembic==1.16.5",
+{%- endif %}
+{%- if cookiecutter.include_ai == "yes" %}
+    "pydantic-ai-slim[{{cookiecutter.ai_providers}}]==1.0.10",
+    "marko==2.1.3",
+{%- endif %}
+]
+
+[project.scripts]
+{{cookiecutter.project_slug}} = "app.cli.main:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest==8.4.1",
+    "pytest-asyncio==1.1.0",
+    "ruff==0.12.7",
+    "ty",
+    "types-psutil==7.0.0.20250801",
+    "pre-commit==4.2.0",
+    "pip-audit==2.9.0",
+{%- if cookiecutter.include_worker == "yes" %}
+    # Development auto-reload for workers
+    "watchdog==4.0.2",
+{%- endif %}
+]
+docs = [
+    "mkdocs==1.6.1",
+    "mkdocs-material==9.6.16",
+    "mkdocstrings[python]==0.30.0",
+    "mkdocs-gen-files==0.5.0",
+    "pymdown-extensions==10.16.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["app"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py{{ cookiecutter.python_version.replace('.', '') }}"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP"]  # Added UP for pyupgrade (modern Python syntax)
+ignore = []
+fixable = ["ALL"]
+unfixable = []
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[tool.ruff.lint.isort]
+force-single-line = false
+force-sort-within-sections = true
+known-first-party = ["app"]
+
+[tool.ty.rules]
+# Configure ty to ignore only genuine false positives or unavoidable issues
+# Real type issues should be fixed, not ignored
+unresolved-import = "ignore"              # Missing third-party type stubs (unavoidable)
+unresolved-attribute = "ignore"           # Some dynamic attribute access in Flet is unavoidable
+invalid-argument-type = "ignore"          # Flet dynamic attributes and colors
+non-subscriptable = "ignore"             # Flet page.controls access patterns
+unsupported-operator = "ignore"          # Flet value comparisons with None
+possibly-unbound-attribute = "ignore"    # Flet dynamic component properties
+call-non-callable = "ignore"             # Dynamic middleware registration patterns
+invalid-return-type = "ignore"           # Flet component return type flexibility
+
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[dependency-groups]
+dev = [
+    "httpx>=0.28.1",
+]

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/scripts/entrypoint.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+
+set -e
+
+# More comprehensive venv cleanup to prevent Docker container conflicts
+if [ -d ".venv" ]; then
+    echo "🧹 Found existing .venv directory, checking compatibility..."
+    
+    # Check if .venv has issues (broken symlinks, wrong Python version, etc.)
+    if [ -L ".venv/bin/python3" ] && [ ! -e ".venv/bin/python3" ]; then
+        echo "🧹 Cleaning up broken venv symlinks..."
+        rm -rf .venv
+    elif [ -f ".venv/bin/python3" ]; then
+        # Check if the Python executable is compatible and accessible
+        if ! .venv/bin/python3 --version > /dev/null 2>&1; then
+            echo "🧹 Cleaning up incompatible venv..."
+            rm -rf .venv
+        fi
+    elif [ ! -w ".venv" ] || [ ! -x ".venv" ]; then
+        # Check for permission issues in Docker containers
+        echo "🧹 Cleaning up venv with permission issues..."
+        rm -rf .venv
+    else
+        # If directory exists but has no python executable, clean it up
+        if [ ! -f ".venv/bin/python3" ] && [ ! -f ".venv/bin/python" ]; then
+            echo "🧹 Cleaning up incomplete venv..."
+            rm -rf .venv
+        fi
+    fi
+fi
+
+# Configure UV environment based on execution context
+if [ -n "$DOCKER_CONTAINER" ] || [ "$USER" = "root" ]; then
+    echo "🐳 Running in Docker container, configuring UV for containerized environment..."
+    
+    # Set Docker-specific UV configuration
+    export UV_PROJECT_ENVIRONMENT=/code/.venv
+    export UV_LINK_MODE=copy
+    export VIRTUAL_ENV=/code/.venv
+    
+    # Ensure .venv path is in PATH for CLI commands
+    export PATH="/code/.venv/bin:$PATH"
+    
+    echo "✅ UV configured for Docker: UV_PROJECT_ENVIRONMENT=/code/.venv"
+else
+    echo "🖥️  Running in local environment, UV will use project defaults"
+    
+    # Ensure we don't inherit Docker environment variables
+    unset UV_PROJECT_ENVIRONMENT
+    unset UV_SYSTEM_PYTHON
+    
+    # Let UV auto-detect local .venv
+    echo "✅ UV configured for local development"
+fi
+
+# Pop run_command from arguments
+run_command="$1"
+shift
+
+if [ "$run_command" = "webserver" ]; then
+    # Web server (FastAPI + Flet)
+    uv run python -m app.entrypoints.webserver
+elif [ "$run_command" = "scheduler" ]; then
+    # Scheduler component
+    uv run python -m app.entrypoints.scheduler
+elif [ "$run_command" = "lint" ]; then
+    uv run ruff check .
+elif [ "$run_command" = "typecheck" ]; then
+    uv run mypy .
+elif [ "$run_command" = "test" ]; then
+    uv run pytest "$@"
+elif [ "$run_command" = "health" ]; then
+    uv run python -m app.cli.health check "$@"
+elif [ "$run_command" = "help" ]; then
+    echo "Available commands:"
+    echo "  webserver   - Run FastAPI + Flet web server"
+    echo "  scheduler   - Run scheduler component"
+    echo "  health      - Check system health status"
+    echo "  lint        - Run ruff linting"
+    echo "  typecheck   - Run mypy type checking"
+    echo "  test        - Run pytest test suite"
+    echo "  help        - Show this help message"
+else
+    echo "Unknown command: $run_command"
+    echo "Available commands: webserver, scheduler, health, lint, typecheck, test, help"
+    exit 1
+fi

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/scripts/entrypoint.sh.j2

@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+
+set -e
+
+# More comprehensive venv cleanup to prevent Docker container conflicts
+if [ -d ".venv" ]; then
+    echo "🧹 Found existing .venv directory, checking compatibility..."
+
+    # Check if .venv has issues (broken symlinks, wrong Python version, etc.)
+    if [ -L ".venv/bin/python3" ] && [ ! -e ".venv/bin/python3" ]; then
+        echo "🧹 Cleaning up broken venv symlinks..."
+        rm -rf .venv
+    elif [ -f ".venv/bin/python3" ]; then
+        # Check if the Python executable is compatible and accessible
+        if ! .venv/bin/python3 --version > /dev/null 2>&1; then
+            echo "🧹 Cleaning up incompatible venv..."
+            rm -rf .venv
+        fi
+    elif [ ! -w ".venv" ] || [ ! -x ".venv" ]; then
+        # Check for permission issues in Docker containers
+        echo "🧹 Cleaning up venv with permission issues..."
+        rm -rf .venv
+    else
+        # If directory exists but has no python executable, clean it up
+        if [ ! -f ".venv/bin/python3" ] && [ ! -f ".venv/bin/python" ]; then
+            echo "🧹 Cleaning up incomplete venv..."
+            rm -rf .venv
+        fi
+    fi
+fi
+
+# Configure UV for Docker container (this is always a Docker entrypoint)
+echo "🐳 Configuring UV for Docker container..."
+
+# Set Docker-specific UV configuration
+export UV_PROJECT_ENVIRONMENT=/code/.venv
+export UV_LINK_MODE=copy
+export VIRTUAL_ENV=/code/.venv
+
+# Ensure .venv path is in PATH for CLI commands
+export PATH="/code/.venv/bin:$PATH"
+
+echo "✅ UV configured for Docker: UV_PROJECT_ENVIRONMENT=/code/.venv"
+
+# Pop run_command from arguments
+run_command="$1"
+shift
+
+if [ "$run_command" = "webserver" ]; then
+    # Web server (FastAPI + Flet)
+    uv run python -m app.entrypoints.webserver
+elif [ "$run_command" = "scheduler" ]; then
+    # Scheduler component
+    uv run python -m app.entrypoints.scheduler
+elif [ "$run_command" = "worker" ]; then
+    # Worker component using STANDARD arq CLI
+    queue_type="${1:-system}"  # Default to system queue if not specified
+    shift
+
+    # Build the module path for the queue
+    worker_module="app.components.worker.queues.${queue_type}.WorkerSettings"
+
+    # Development mode auto-reload (APP_ENV from .env or WORKER_WATCH override)
+    if [ "$APP_ENV" = "dev" ] || [ "$WORKER_WATCH" = "true" ]; then
+        echo "🔄 Starting ${queue_type} worker with auto-reload..."
+        exec uv run python -m arq "${worker_module}" --watch /code/app "$@"
+    else
+        echo "🚀 Starting ${queue_type} worker..."
+        exec uv run python -m arq "${worker_module}" "$@"
+    fi
+elif [ "$run_command" = "lint" ]; then
+    uv run ruff check .
+elif [ "$run_command" = "typecheck" ]; then
+    uv run mypy .
+elif [ "$run_command" = "test" ]; then
+    uv run pytest "$@"
+elif [ "$run_command" = "health" ]; then
+    uv run python -m app.cli.health check "$@"
+elif [ "$run_command" = "help" ]; then
+    echo "Available commands:"
+    echo "  webserver   - Run FastAPI + Flet web server"
+    echo "  scheduler   - Run scheduler component"
+    echo "  worker      - Run arq worker (standard arq CLI patterns)"
+    echo "  health      - Check system health status"
+    echo "  lint        - Run ruff linting"
+    echo "  typecheck   - Run mypy type checking"
+    echo "  test        - Run pytest test suite"
+    echo "  help        - Show this help message"
+else
+    echo "Unknown command: $run_command"
+    echo "Available commands: webserver, scheduler, worker, health, lint, typecheck, test, help"
+    exit 1
+fi

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/scripts/gen_docs.py

@@ -0,0 +1,16 @@
+# scripts/gen_docs.py
+"""
+A script to dynamically generate documentation files for MkDocs.
+This is run automatically by the mkdocs-gen-files plugin.
+"""
+
+import mkdocs_gen_files  # noqa: F401
+
+print("--- Running gen_docs.py ---")
+
+# Copy the root README.md to be the documentation's index page.
+# This allows us to maintain a single source of truth for the project's
+# main landing page, which is visible on both GitHub and the docs site.
+with open("README.md") as readme, open("docs/index.md", "w") as index:
+    index.write(readme.read())
+    print("✓ Copied README.md to docs/index.md")

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/tests/api/__init__.py

@@ -0,0 +1 @@
+# API tests package

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/tests/api/test_auth_endpoints.py.j2

@@ -0,0 +1,307 @@
+"""
+Tests for authentication API endpoints.
+
+This module tests the auth endpoints including user registration,
+login, token validation, and protected endpoint access.
+"""
+
+import pytest
+from app.core.security import create_access_token
+from app.models.user import UserCreate
+from app.services.auth.user_service import UserService
+from fastapi import status
+from fastapi.testclient import TestClient
+from sqlmodel import Session
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+
+class TestAuthEndpoints:
+    """Test auth API endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_register_new_user(
+        self, async_client_with_db: TestClient, async_db_session: AsyncSession
+    ):
+        """Test user registration with valid data."""
+        user_data = {
+            "email": "test@example.com",
+            "full_name": "Test User",
+            "password": "testpassword123"
+        }
+
+        response = async_client_with_db.post("/api/v1/auth/register", json=user_data)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert data["email"] == user_data["email"]
+        assert data["full_name"] == user_data["full_name"]
+        assert data["is_active"] is True
+        assert "id" in data
+        assert "created_at" in data
+        # Ensure password is not returned
+        assert "password" not in data
+        assert "hashed_password" not in data
+
+    @pytest.mark.asyncio
+    async def test_register_duplicate_email(
+        self, async_client_with_db: TestClient, async_db_session: AsyncSession
+    ):
+        """Test registration with already existing email."""
+        # Create a user first
+        user_service = UserService(async_db_session)
+        existing_user = UserCreate(
+            email="existing@example.com",
+            full_name="Existing User",
+            password="password123"
+        )
+        await user_service.create_user(existing_user)
+
+        # Try to register with same email
+        duplicate_user_data = {
+            "email": "existing@example.com",
+            "full_name": "Another User",
+            "password": "differentpassword"
+        }
+
+        response = async_client_with_db.post(
+            "/api/v1/auth/register", json=duplicate_user_data
+        )
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert "already registered" in response.json()["detail"].lower()
+
+    @pytest.mark.asyncio
+    async def test_register_invalid_data(self, async_client_with_db: TestClient):
+        """Test registration with invalid data."""
+        invalid_user_data = {
+            "email": "not-an-email",  # Invalid email format
+            "password": "123"  # Too short
+        }
+
+        response = async_client_with_db.post(
+            "/api/v1/auth/register", json=invalid_user_data
+        )
+
+        assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+
+    @pytest.mark.asyncio
+    async def test_login_valid_credentials(
+        self, async_client_with_db: TestClient, async_db_session: AsyncSession
+    ):
+        """Test login with valid credentials."""
+        # Create a user first
+        user_service = UserService(async_db_session)
+        user_data = UserCreate(
+            email="login@example.com",
+            full_name="Login User",
+            password="loginpassword123"
+        )
+        await user_service.create_user(user_data)
+
+        # Login with valid credentials
+        login_data = {
+            "username": "login@example.com",  # OAuth2 uses username field
+            "password": "loginpassword123"
+        }
+
+        response = async_client_with_db.post("/api/v1/auth/token", data=login_data)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert "access_token" in data
+        assert data["token_type"] == "bearer"
+        assert len(data["access_token"]) > 0
+
+    @pytest.mark.asyncio
+    async def test_login_invalid_email(self, async_client_with_db: TestClient):
+        """Test login with non-existent email."""
+        login_data = {
+            "username": "nonexistent@example.com",
+            "password": "somepassword"
+        }
+
+        response = async_client_with_db.post("/api/v1/auth/token", data=login_data)
+
+        assert response.status_code == status.HTTP_401_UNAUTHORIZED
+        assert "incorrect" in response.json()["detail"].lower()
+
+    @pytest.mark.asyncio
+    async def test_login_invalid_password(
+        self, async_client_with_db: TestClient, async_db_session: AsyncSession
+    ):
+        """Test login with wrong password."""
+        # Create a user first
+        user_service = UserService(async_db_session)
+        user_data = UserCreate(
+            email="wrongpass@example.com",
+            full_name="Wrong Pass User",
+            password="correctpassword"
+        )
+        await user_service.create_user(user_data)
+
+        # Login with wrong password
+        login_data = {
+            "username": "wrongpass@example.com",
+            "password": "wrongpassword"
+        }
+
+        response = async_client_with_db.post("/api/v1/auth/token", data=login_data)
+
+        assert response.status_code == status.HTTP_401_UNAUTHORIZED
+        assert "incorrect" in response.json()["detail"].lower()
+
+    @pytest.mark.asyncio
+    async def test_get_current_user_valid_token(
+        self, async_client_with_db: TestClient, async_db_session: AsyncSession
+    ):
+        """Test getting current user with valid token."""
+        # Create a user first
+        user_service = UserService(async_db_session)
+        user_data = UserCreate(
+            email="currentuser@example.com",
+            full_name="Current User",
+            password="password123"
+        )
+        created_user = await user_service.create_user(user_data)
+
+        # Create a valid token
+        token = create_access_token(data={"sub": created_user.email})
+
+        # Get current user
+        response = async_client_with_db.get(
+            "/api/v1/auth/me",
+            headers={"Authorization": f"Bearer {token}"}
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert data["email"] == created_user.email
+        assert data["full_name"] == created_user.full_name
+        assert data["id"] == created_user.id
+
+    @pytest.mark.asyncio
+    async def test_get_current_user_invalid_token(
+        self, async_client_with_db: TestClient
+    ):
+        """Test getting current user with invalid token."""
+        response = async_client_with_db.get(
+            "/api/v1/auth/me",
+            headers={"Authorization": "Bearer invalid_token"}
+        )
+
+        assert response.status_code == status.HTTP_401_UNAUTHORIZED
+
+    @pytest.mark.asyncio
+    async def test_get_current_user_no_token(self, async_client_with_db: TestClient):
+        """Test getting current user without token."""
+        response = async_client_with_db.get("/api/v1/auth/me")
+
+        assert response.status_code == status.HTTP_401_UNAUTHORIZED
+
+    @pytest.mark.asyncio
+    async def test_get_current_user_expired_token(
+        self, async_client_with_db: TestClient, async_db_session: AsyncSession
+    ):
+        """Test getting current user with expired token."""
+        # Create a user first
+        user_service = UserService(async_db_session)
+        user_data = UserCreate(
+            email="expiredtoken@example.com",
+            full_name="Expired Token User",
+            password="password123"
+        )
+        created_user = await user_service.create_user(user_data)
+
+        # Create an expired token (negative expiry)
+        from datetime import timedelta
+        expired_token = create_access_token(
+            data={"sub": created_user.email},
+            expires_delta=timedelta(seconds=-1)
+        )
+
+        # Try to get current user with expired token
+        response = async_client_with_db.get(
+            "/api/v1/auth/me",
+            headers={"Authorization": f"Bearer {expired_token}"}
+        )
+
+        assert response.status_code == status.HTTP_401_UNAUTHORIZED
+
+
+class TestAuthIntegration:
+    """Integration tests for auth flow."""
+
+    @pytest.mark.asyncio
+    async def test_full_auth_flow(
+        self, async_client_with_db: TestClient, async_db_session: AsyncSession
+    ):
+        """Test complete auth flow: register -> login -> protected endpoint."""
+        # Step 1: Register new user
+        user_data = {
+            "email": "fullflow@example.com",
+            "full_name": "Full Flow User",
+            "password": "fullflowpassword123"
+        }
+
+        register_response = async_client_with_db.post(
+            "/api/v1/auth/register", json=user_data
+        )
+        assert register_response.status_code == status.HTTP_200_OK
+
+        # Step 2: Login with credentials
+        login_data = {
+            "username": user_data["email"],
+            "password": user_data["password"]
+        }
+
+        login_response = async_client_with_db.post(
+            "/api/v1/auth/token", data=login_data
+        )
+        assert login_response.status_code == status.HTTP_200_OK
+
+        token = login_response.json()["access_token"]
+
+        # Step 3: Access protected endpoint
+        me_response = async_client_with_db.get(
+            "/api/v1/auth/me",
+            headers={"Authorization": f"Bearer {token}"}
+        )
+
+        assert me_response.status_code == status.HTTP_200_OK
+        user_info = me_response.json()
+        assert user_info["email"] == user_data["email"]
+        assert user_info["full_name"] == user_data["full_name"]
+
+    @pytest.mark.asyncio
+    async def test_user_persistence_across_requests(
+        self, async_client_with_db: TestClient, async_db_session: AsyncSession
+    ):
+        """Test that users are properly persisted in database."""
+        # Register user
+        user_data = {
+            "email": "persistent@example.com",
+            "full_name": "Persistent User",
+            "password": "persistentpassword"
+        }
+
+        async_client_with_db.post("/api/v1/auth/register", json=user_data)
+
+        # Login in separate request
+        login_data = {
+            "username": user_data["email"],
+            "password": user_data["password"]
+        }
+
+        login_response = async_client_with_db.post(
+            "/api/v1/auth/token", data=login_data
+        )
+        assert login_response.status_code == status.HTTP_200_OK
+
+        # Verify user exists in database
+        user_service = UserService(async_db_session)
+        db_user = await user_service.get_user_by_email(user_data["email"])
+
+        assert db_user is not None
+        assert db_user.email == user_data["email"]
+        assert db_user.full_name == user_data["full_name"]
+        assert db_user.is_active is True