solokit 0.1.1__py3-none-any.whl

solokit/templates/ml_ai_fastapi/tier-3-comprehensive/tests/integration/conftest.py

@@ -0,0 +1,74 @@
+"""
+Integration test fixtures
+"""
+
+from collections.abc import AsyncGenerator
+from typing import Any
+
+import pytest
+from httpx import ASGITransport, AsyncClient  # type: ignore[import-not-found]
+from sqlalchemy.ext.asyncio import create_async_engine  # type: ignore[import-not-found]
+from sqlalchemy.orm import sessionmaker  # type: ignore[import-not-found]
+from sqlmodel import SQLModel  # type: ignore[import-not-found]
+from sqlmodel.ext.asyncio.session import AsyncSession  # type: ignore[import-not-found]
+from src.api.dependencies import get_db  # type: ignore[import-not-found]
+from src.main import app  # type: ignore[import-not-found]
+
+# Use a separate test database for integration tests
+INTEGRATION_DATABASE_URL = "sqlite+aiosqlite:///./test_integration.db"
+
+
+@pytest.fixture(scope="function")
+async def integration_db_engine() -> AsyncGenerator[Any, None]:
+    """Create a test database engine for integration tests."""
+    engine = create_async_engine(
+        INTEGRATION_DATABASE_URL,
+        echo=False,
+        future=True,
+    )
+
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+
+    yield engine
+
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.drop_all)
+
+    await engine.dispose()
+
+
+@pytest.fixture(scope="function")
+async def integration_db_session(
+    integration_db_engine: Any,
+) -> AsyncGenerator[AsyncSession, None]:
+    """Create a test database session for integration tests."""
+    async_session_maker = sessionmaker(
+        integration_db_engine,
+        class_=AsyncSession,
+        expire_on_commit=False,
+    )
+
+    async with async_session_maker() as session:
+        yield session
+
+
+@pytest.fixture(scope="function")
+async def integration_client(
+    integration_db_session: AsyncSession,
+) -> AsyncGenerator[AsyncClient, None]:
+    """
+    Create a test client for integration tests.
+    """
+
+    async def override_get_db() -> AsyncGenerator[AsyncSession, None]:
+        yield integration_db_session
+
+    app.dependency_overrides[get_db] = override_get_db
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://testserver", timeout=30.0
+    ) as ac:  # nosec B113 - Test client timeout is set to 30 seconds
+        yield ac
+
+    app.dependency_overrides.clear()

solokit/templates/ml_ai_fastapi/tier-3-comprehensive/tests/integration/test_api.py

@@ -0,0 +1,131 @@
+"""
+Integration tests for API endpoints
+"""
+
+import pytest
+from httpx import AsyncClient  # type: ignore[import-not-found]
+
+
+@pytest.mark.integration
+@pytest.mark.api
+class TestItemAPIIntegration:
+    """Integration tests for Item API endpoints."""
+
+    async def test_create_and_retrieve_item(self, integration_client: AsyncClient) -> None:
+        """Test full cycle: create item and retrieve it."""
+        # Create an item
+        create_response = await integration_client.post(
+            "/api/v1/items",
+            json={
+                "name": "Integration Test Item",
+                "description": "Full stack test",
+                "price": 29.99,
+            },
+        )
+        assert create_response.status_code == 201
+        created_item = create_response.json()
+        assert created_item["name"] == "Integration Test Item"
+        item_id = created_item["id"]
+
+        # Retrieve the item
+        get_response = await integration_client.get(f"/api/v1/items/{item_id}")
+        assert get_response.status_code == 200
+        retrieved_item = get_response.json()
+        assert retrieved_item["id"] == item_id
+        assert retrieved_item["name"] == "Integration Test Item"
+
+    async def test_create_update_delete_workflow(self, integration_client: AsyncClient) -> None:
+        """Test complete CRUD workflow."""
+        # Create
+        create_response = await integration_client.post(
+            "/api/v1/items",
+            json={"name": "Workflow Item", "price": 10.0},
+        )
+        assert create_response.status_code == 201
+        item_id = create_response.json()["id"]
+
+        # Update
+        update_response = await integration_client.patch(
+            f"/api/v1/items/{item_id}",
+            json={"name": "Updated Item", "price": 15.0},
+        )
+        assert update_response.status_code == 200
+        updated_item = update_response.json()
+        assert updated_item["name"] == "Updated Item"
+        assert updated_item["price"] == 15.0
+
+        # Verify update
+        get_response = await integration_client.get(f"/api/v1/items/{item_id}")
+        assert get_response.status_code == 200
+        assert get_response.json()["name"] == "Updated Item"
+
+        # Delete
+        delete_response = await integration_client.delete(f"/api/v1/items/{item_id}")
+        assert delete_response.status_code == 204
+
+        # Verify deletion
+        get_deleted_response = await integration_client.get(f"/api/v1/items/{item_id}")
+        assert get_deleted_response.status_code == 404
+
+    async def test_list_items_pagination(self, integration_client: AsyncClient) -> None:
+        """Test listing items with pagination."""
+        # Create multiple items
+        for i in range(15):
+            await integration_client.post(
+                "/api/v1/items",
+                json={"name": f"Item {i}", "price": float(i)},
+            )
+
+        # Test default pagination
+        response = await integration_client.get("/api/v1/items")
+        assert response.status_code == 200
+        items = response.json()
+        assert len(items) <= 100
+
+        # Test custom pagination
+        response = await integration_client.get("/api/v1/items?skip=5&limit=5")
+        assert response.status_code == 200
+        items = response.json()
+        assert len(items) == 5
+
+    async def test_validation_errors(self, integration_client: AsyncClient) -> None:
+        """Test API validation errors."""
+        # Missing required field
+        response = await integration_client.post(
+            "/api/v1/items",
+            json={"description": "Missing name and price"},
+        )
+        assert response.status_code == 422
+
+        # Invalid price (must be > 0)
+        response = await integration_client.post(
+            "/api/v1/items",
+            json={"name": "Invalid Price", "price": -10.0},
+        )
+        assert response.status_code == 422
+
+    async def test_not_found_error(self, integration_client: AsyncClient) -> None:
+        """Test 404 error for non-existent item."""
+        response = await integration_client.get("/api/v1/items/99999")
+        assert response.status_code == 404
+
+
+@pytest.mark.integration
+class TestHealthEndpoints:
+    """Integration tests for health check endpoints."""
+
+    async def test_health_endpoints_integration(self, integration_client: AsyncClient) -> None:
+        """Test all health check endpoints."""
+        # Health check
+        response = await integration_client.get("/health")
+        assert response.status_code == 200
+        assert response.json()["status"] == "healthy"
+
+        # Readiness check
+        response = await integration_client.get("/health/ready")
+        assert response.status_code == 200
+
+        # Liveness check
+        response = await integration_client.get("/health/live")
+        assert response.status_code == 200
+        assert response.json()["status"] == "alive"

solokit/templates/ml_ai_fastapi/tier-4-production/pyproject.toml.tier4.template

@@ -0,0 +1,162 @@
+[project]
+name = "{project_name}"
+version = "0.1.0"
+description = "{project_description}"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi==0.115.6",
+    "uvicorn[standard]==0.34.0",
+    "pydantic==2.12.4",
+    "pydantic-core==2.41.5",
+    "pydantic-settings==2.11.0",
+    "sqlmodel==0.0.25",
+    "sqlalchemy==2.0.37",
+    "psycopg2-binary==2.9.10",
+    "alembic==1.14.0",
+    "python-dotenv==1.2.1",
+    "asyncpg==0.30.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest==8.3.4",
+    "pytest-cov==6.0.0",
+    "pytest-asyncio==0.25.2",
+    "httpx==0.28.1",
+    "aiosqlite==0.20.0",
+    "ruff==0.9.2",
+    "pyright==1.1.396",
+]
+
+security = [
+    "detect-secrets==1.5.0",
+    "pip-audit==2.7.3",
+    "bandit[toml]==1.8.0",
+    "pre-commit==4.0.1",
+]
+
+quality = [
+    "radon==6.0.1",
+    "vulture==2.14",
+    "mutmut==3.3.1",
+    "locust==2.42.2",
+    "semgrep==1.142.1",
+    "coverage[toml]==7.11.1",
+]
+
+production = [
+    "prometheus-client==0.23.1",
+    "statsd==4.0.1",
+    "structlog==25.5.0",
+    "python-json-logger==4.0.0",
+    "fastapi-health==0.4.0",
+    "sentry-sdk==2.27.0",
+    "opentelemetry-instrumentation-fastapi==0.59b0",
+    "gunicorn==23.0.0",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["src"]
+
+# Ruff configuration
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "N",  # pep8-naming
+    "UP", # pyupgrade
+    "B",  # flake8-bugbear
+    "S",  # bandit security checks
+]
+
+ignore = [
+    "E501",  # line too long (handled by formatter)
+    "S101",  # assert used (we use asserts in tests)
+]
+
+exclude = [
+    ".git",
+    ".venv",
+    "__pycache__",
+    "alembic/versions",
+    ".pytest_cache",
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.ruff.isort]
+known-first-party = ["src"]
+
+[tool.ruff.per-file-ignores]
+"tests/*" = ["S101"]
+
+# Pytest configuration
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+    "slow: Slow running tests",
+    "api: API tests",
+    "db: Database tests",
+]
+addopts = [
+    "-v",
+    "--strict-markers",
+    "--tb=short",
+    "--cov=src",
+    "--cov-report=term-missing",
+    "--cov-report=html",
+    "--cov-report=xml",
+    "--cov-fail-under=80",
+]
+
+# Coverage configuration
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "tests/*",
+    "alembic/*",
+    "*/__init__.py",
+]
+branch = true
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+skip_covered = false
+fail_under = 80
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+]
+
+# Bandit security configuration
+[tool.bandit]
+exclude_dirs = ["tests", ".venv", "venv", "alembic/versions"]
+skips = ["B101"]
+
+# Scripts
+[project.scripts]
+dev = "uvicorn src.main:app --reload --host 0.0.0.0 --port 8000"
+prod = "gunicorn src.main:app -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000"

solokit/templates/ml_ai_fastapi/tier-4-production/requirements-prod.txt

@@ -0,0 +1,25 @@
+# Production Dependencies for {project_name}
+
+# Monitoring & Metrics
+prometheus-client==0.23.1
+statsd==4.0.1
+
+# Structured Logging
+structlog==25.5.0
+python-json-logger==4.0.0
+
+# Health Checks
+fastapi-health==0.4.0
+
+# Error Tracking
+sentry-sdk==2.27.0
+
+# OpenTelemetry (optional - may conflict with semgrep)
+opentelemetry-api==1.38.0
+opentelemetry-sdk==1.38.0
+opentelemetry-instrumentation==0.59b0
+opentelemetry-instrumentation-fastapi==0.59b0
+opentelemetry-exporter-otlp==1.38.0
+
+# Performance
+gunicorn==23.0.0

solokit/templates/ml_ai_fastapi/tier-4-production/src/api/routes/metrics.py

@@ -0,0 +1,19 @@
+"""
+Prometheus metrics endpoint
+"""
+
+from fastapi import APIRouter, Response  # type: ignore[import-not-found]
+from src.core.monitoring import get_metrics  # type: ignore[import-not-found]
+
+router = APIRouter()
+
+
+@router.get("/metrics")
+async def metrics() -> Response:
+    """
+    Prometheus metrics endpoint.
+
+    Returns:
+        Response: Prometheus metrics in text format
+    """
+    return get_metrics()

solokit/templates/ml_ai_fastapi/tier-4-production/src/core/logging.py

@@ -0,0 +1,74 @@
+"""
+Structured logging configuration using structlog
+"""
+
+import logging
+import sys
+from typing import Any
+
+import structlog  # type: ignore[import-not-found]
+from src.core.config import settings  # type: ignore[import-not-found]
+from structlog.types import EventDict, Processor  # type: ignore[import-not-found]
+
+
+def add_app_context(logger: Any, method_name: str, event_dict: EventDict) -> EventDict:
+    """
+    Add application context to log events.
+
+    Args:
+        logger: Logger instance
+        method_name: Method name
+        event_dict: Event dictionary
+
+    Returns:
+        EventDict: Updated event dictionary
+    """
+    event_dict["app"] = settings.APP_NAME
+    event_dict["env"] = settings.ENVIRONMENT
+    return event_dict
+
+
+def configure_logging() -> None:
+    """
+    Configure structured logging with structlog.
+    """
+    # Determine log level
+    log_level = getattr(logging, settings.LOG_LEVEL.upper(), logging.INFO)  # type: ignore[attr-defined]
+
+    # Configure standard library logging
+    logging.basicConfig(  # type: ignore[attr-defined]
+        format="%(message)s",
+        stream=sys.stdout,
+        level=log_level,
+    )
+
+    # Configure structlog
+    processors: list[Processor] = [
+        structlog.contextvars.merge_contextvars,
+        add_app_context,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.add_logger_name,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+    ]
+
+    # Add JSON or console rendering based on settings
+    if settings.LOG_FORMAT == "json":
+        processors.append(structlog.processors.JSONRenderer())
+    else:
+        processors.append(structlog.dev.ConsoleRenderer())
+
+    structlog.configure(
+        processors=processors,
+        wrapper_class=structlog.stdlib.BoundLogger,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+
+# Initialize logging
+configure_logging()
+
+# Create logger instance
+logger = structlog.get_logger()

solokit/templates/ml_ai_fastapi/tier-4-production/src/core/monitoring.py

@@ -0,0 +1,68 @@
+"""
+Prometheus metrics setup for monitoring
+"""
+
+from fastapi import Response  # type: ignore[import-not-found]
+from prometheus_client import (  # type: ignore[import-not-found]
+    CONTENT_TYPE_LATEST,
+    CollectorRegistry,
+    Counter,
+    Gauge,
+    Histogram,
+    generate_latest,
+)
+
+# Create a custom registry
+registry = CollectorRegistry()
+
+# Request metrics
+http_requests_total = Counter(
+    "http_requests_total",
+    "Total HTTP requests",
+    ["method", "endpoint", "status"],
+    registry=registry,
+)
+
+http_request_duration_seconds = Histogram(
+    "http_request_duration_seconds",
+    "HTTP request duration in seconds",
+    ["method", "endpoint"],
+    registry=registry,
+)
+
+# Application metrics
+active_users = Gauge(
+    "active_users",
+    "Number of active users",
+    registry=registry,
+)
+
+database_connections = Gauge(
+    "database_connections",
+    "Number of active database connections",
+    registry=registry,
+)
+
+# Business metrics
+items_created_total = Counter(
+    "items_created_total",
+    "Total number of items created",
+    registry=registry,
+)
+
+items_deleted_total = Counter(
+    "items_deleted_total",
+    "Total number of items deleted",
+    registry=registry,
+)
+
+
+def get_metrics() -> Response:
+    """
+    Generate Prometheus metrics response.
+
+    Returns:
+        Response: Prometheus metrics in text format
+    """
+    metrics = generate_latest(registry)
+    return Response(content=metrics, media_type=CONTENT_TYPE_LATEST)

solokit/templates/ml_ai_fastapi/tier-4-production/src/core/sentry.py

@@ -0,0 +1,66 @@
+"""
+Sentry error tracking integration
+"""
+
+from typing import Any
+
+import sentry_sdk  # type: ignore[import-not-found]
+from sentry_sdk.integrations.fastapi import FastApiIntegration  # type: ignore[import-not-found]
+from sentry_sdk.integrations.sqlalchemy import (
+    SqlalchemyIntegration,  # type: ignore[import-not-found]
+)
+from src.core.config import settings  # type: ignore[import-not-found]
+
+
+def initialize_sentry() -> None:
+    """
+    Initialize Sentry SDK for error tracking.
+    Only initializes in non-development environments.
+    """
+    # Only initialize Sentry in production/staging
+    if settings.ENVIRONMENT == "development":
+        return
+
+    # Check if Sentry DSN is configured
+    sentry_dsn = getattr(settings, "SENTRY_DSN", None)
+    if not sentry_dsn:
+        return
+
+    sentry_sdk.init(
+        dsn=sentry_dsn,
+        environment=settings.ENVIRONMENT,
+        release=f"{settings.APP_NAME}@{settings.APP_VERSION}",
+        traces_sample_rate=0.1,  # 10% of transactions for performance monitoring
+        profiles_sample_rate=0.1,  # 10% of transactions for profiling
+        integrations=[
+            FastApiIntegration(),
+            SqlalchemyIntegration(),
+        ],
+        # Set traces_sample_rate to 1.0 to capture 100% of transactions
+        # Adjust this value in production to reduce overhead
+        send_default_pii=False,  # Don't send personally identifiable information
+        before_send=before_send_filter,
+    )
+
+
+def before_send_filter(event: dict[str, Any], hint: dict[str, Any]) -> dict[str, Any] | None:
+    """
+    Filter events before sending to Sentry.
+
+    Args:
+        event: Sentry event
+        hint: Additional context
+
+    Returns:
+        dict | None: Event to send or None to skip
+    """
+    # Filter out specific exceptions or add custom logic
+    # Example: Don't send 404 errors
+    if "exc_info" in hint:
+        exc_type, exc_value, tb = hint["exc_info"]
+        if exc_type.__name__ == "HTTPException":
+            # Don't send HTTP 404 errors
+            if hasattr(exc_value, "status_code") and exc_value.status_code == 404:
+                return None
+
+    return event

solokit/templates/ml_ai_fastapi/tier-4-production/src/middleware/__init__.py

@@ -0,0 +1,3 @@
+"""
+Middleware package for request/response processing
+"""