cuneus 0.2.9__tar.gz → 0.2.10__tar.gz

{cuneus-0.2.9 → cuneus-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cuneus
-Version: 0.2.9
+Version: 0.2.10
 Summary: ASGI application wrapper
 Project-URL: Homepage, https://github.com/rmyers/cuneus
 Project-URL: Documentation, https://github.com/rmyers/cuneus#readme
@@ -24,11 +24,15 @@ Requires-Dist: alembic>=1.13.0; extra == 'database'
 Requires-Dist: asyncpg>=0.29.0; extra == 'database'
 Requires-Dist: sqlalchemy[asyncio]>=2.0; extra == 'database'
 Provides-Extra: dev
+Requires-Dist: aiosqlite[dev]>=0.22.1; extra == 'dev'
 Requires-Dist: alembic>=1.13.0; extra == 'dev'
 Requires-Dist: asgi-lifespan>=2.1.0; extra == 'dev'
 Requires-Dist: asyncpg>=0.29.0; extra == 'dev'
 Requires-Dist: httpx>=0.27; extra == 'dev'
 Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: opentelemetry-api; extra == 'dev'
+Requires-Dist: opentelemetry-instrumentation; extra == 'dev'
+Requires-Dist: opentelemetry-sdk; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'
 Requires-Dist: pytest-mock; extra == 'dev'

{cuneus-0.2.9 → cuneus-0.2.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cuneus"
-version = "0.2.9"
+version = "0.2.10"
 description = "ASGI application wrapper"
 readme = "README.md"
 authors = [{ name = "Robert Myers", email = "robert@julython.org" }]
@@ -18,20 +18,24 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-database = ["sqlalchemy[asyncio]>=2.0", "asyncpg>=0.29.0", "alembic>=1.13.0"]
-redis = ["redis>=5.0"]
-all = ["cuneus[database,redis]"]
 dev = [
+    "asgi-lifespan>=2.1.0",
+    "aiosqlite[dev]>=0.22.1",
     "cuneus[all]",
+    "opentelemetry-sdk",
+    "opentelemetry-api",
+    "opentelemetry-instrumentation",
     "pytest>=8.0",
     "pytest-asyncio>=0.23",
     "pytest-cov>=4.0",
     "pytest-mock",
     "httpx>=0.27",
-    "asgi-lifespan>=2.1.0",
     "ruff>=0.3",
     "mypy>=1.8",
 ]
+database = ["sqlalchemy[asyncio]>=2.0", "asyncpg>=0.29.0", "alembic>=1.13.0"]
+redis = ["redis>=5.0"]
+all = ["cuneus[database,redis]"]
 
 [project.scripts]
 cuneus = "cuneus.cli:main"

{cuneus-0.2.9 → cuneus-0.2.10}/src/cuneus/cli.py

@@ -13,9 +13,7 @@ def get_user_cli(config: Settings = Settings()) -> click.Group | None:
     try:
         return cast(click.Group, import_from_string(config.cli_module))
     except (ImportError, AttributeError) as e:
-        click.echo(
-            f"Warning: Could not load CLI from {config.cli_module}: {e}", err=True
-        )
+        click.echo(f"Warning: Could not load CLI from {config.cli_module}: {e}", err=True)
         return None
 
 

{cuneus-0.2.9 → cuneus-0.2.10}/src/cuneus/core/application.py

@@ -41,9 +41,7 @@ class ExtensionConflictError(Exception):
     pass
 
 
-def _instantiate_extension(
-    ext: ExtensionInput, settings: Settings | None = None
-) -> Extension:
+def _instantiate_extension(ext: ExtensionInput, settings: Settings | None = None) -> Extension:
     if isinstance(ext, type) or callable(ext):
         try:
             return ext(settings=settings)
@@ -97,9 +95,7 @@ def build_app(
 
     @svcs.fastapi.lifespan
     @asynccontextmanager
-    async def lifespan(
-        app: FastAPI, registry: svcs.Registry
-    ) -> AsyncIterator[dict[str, Any]]:
+    async def lifespan(app: FastAPI, registry: svcs.Registry) -> AsyncIterator[dict[str, Any]]:
         async with AsyncExitStack() as stack:
             state: dict[str, Any] = {}
 

{cuneus-0.2.9 → cuneus-0.2.10}/src/cuneus/core/exceptions.py

@@ -160,9 +160,7 @@ class ExceptionExtension(BaseExtension):
         app.add_exception_handler(AppException, self._handle_app_exception)  # type: ignore[arg-type]
         app.add_exception_handler(Exception, self._handle_unexpected_exception)
 
-    def _handle_app_exception(
-        self, request: Request, exc: AppException
-    ) -> JSONResponse:
+    def _handle_app_exception(self, request: Request, exc: AppException) -> JSONResponse:
         if exc.status_code >= 500 and self.settings.log_server_errors:
             log.exception("server_error", error_code=exc.error_code)
         else:
@@ -180,9 +178,7 @@ class ExceptionExtension(BaseExtension):
             headers=headers,
         )
 
-    def _handle_unexpected_exception(
-        self, request: Request, exc: Exception
-    ) -> JSONResponse:
+    def _handle_unexpected_exception(self, request: Request, exc: Exception) -> JSONResponse:
         log.exception("unexpected_error", exc_info=exc)
         response: dict[str, Any] = {
             "error": {

{cuneus-0.2.9 → cuneus-0.2.10}/src/cuneus/core/settings.py

@@ -39,7 +39,6 @@ class CuneusBaseSettings(BaseSettings):
 
 
 class Settings(CuneusBaseSettings):
-
     model_config = SettingsConfigDict(
         env_file=".env",
         env_file_encoding="utf-8",

cuneus-0.2.10/src/cuneus/dependencies.py

@@ -0,0 +1,79 @@
+# cuneus/core/dependencies.py
+from __future__ import annotations
+
+import importlib
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Dependency:
+    """A required dependency with install hint."""
+
+    import_name: str
+    package_name: str | None = None  # pip package name if different from import
+
+    @property
+    def pip_name(self) -> str:
+        return self.package_name or self.import_name
+
+
+class MissingDependencyError(ImportError):
+    """Raised when required dependencies are not installed."""
+
+    def __init__(self, extension: str, missing: list[Dependency]):
+        self.extension = extension
+        self.missing = missing
+        packages = " ".join(d.pip_name for d in missing)
+        super().__init__(
+            f"{extension} requires additional dependencies. Install with: uv add {packages}"
+        )
+
+
+def check_dependencies(extension: str, *deps: Dependency) -> None:
+    """
+    Check that dependencies are installed, raise helpful error if not.
+
+    Usage:
+        from cuneus.core.dependencies import check_dependencies, Dependency
+
+        check_dependencies(
+            "DatabaseExtension",
+            Dependency("sqlalchemy"),
+            Dependency("asyncpg"),
+        )
+    """
+    missing = []
+    for dep in deps:
+        try:
+            importlib.import_module(dep.import_name)
+        except ImportError:
+            missing.append(dep)
+
+    if missing:
+        raise MissingDependencyError(extension, missing)
+
+
+def warn_missing(extension: str, *deps: Dependency) -> list[Dependency]:
+    """
+    Check dependencies but only warn, don't raise. Returns list of missing.
+
+    Useful for optional features within an extension.
+    """
+    missing = []
+    for dep in deps:
+        try:
+            importlib.import_module(dep.import_name)
+        except ImportError:
+            missing.append(dep)
+
+    if missing:
+        packages = " ".join(d.pip_name for d in missing)
+        logger.warning(
+            f"{extension}: optional dependencies not installed. "
+            f"Some features disabled. Install with: uv add {packages}"
+        )
+
+    return missing

cuneus-0.2.10/src/cuneus/ext/database.py

@@ -0,0 +1,278 @@
+# cuneus/ext/database.py
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, AsyncIterator
+
+import click
+import svcs
+from fastapi import FastAPI
+from pydantic import Field, SecretStr, computed_field
+from pydantic_settings import SettingsConfigDict
+from structlog.stdlib import get_logger
+
+from ..core.extensions import BaseExtension, HasCLI
+from ..core.settings import CuneusBaseSettings, DEFAULT_TOOL_NAME
+from ..dependencies import Dependency, check_dependencies
+
+check_dependencies(
+    "cuneus.ext.database",
+    Dependency("sqlalchemy"),
+)
+
+from sqlalchemy import URL, make_url, text
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+logger = get_logger(__name__)
+
+
+class DatabaseSettings(CuneusBaseSettings):
+    """Database configuration."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="DATABASE_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+        pyproject_toml_depth=2,
+        pyproject_toml_table_header=("tool", DEFAULT_TOOL_NAME, "database"),
+    )
+
+    # Option 1: Full URL (takes precedence if set)
+    url: str | None = None
+
+    # Option 2: Individual parts
+    driver: str = "postgresql+asyncpg"
+    host: str = "localhost"
+    port: int = 5432
+    name: str = "app"
+    username: str | None = None
+    password: SecretStr | None = None
+
+    # Pool settings
+    pool_size: int = 5
+    pool_max_overflow: int = 10
+    pool_recycle: int = 3600
+    echo: bool = False
+
+    # Alembic
+    alembic_config: Path = Path("alembic.ini")
+
+    @computed_field
+    @property
+    def url_parsed(self) -> URL:
+        """Get SQLAlchemy URL, either from url string or constructed from parts."""
+        if self.url:
+            return make_url(self.url)
+
+        needs_opts = "sqlite" not in self.driver
+        password_value = self.password.get_secret_value() if self.password else None
+        password = password_value if needs_opts else None
+
+        return URL.create(
+            drivername=self.driver,
+            username=self.username if needs_opts else None,
+            password=password,
+            host=self.host if needs_opts else None,
+            port=self.port if needs_opts else None,
+            database=self.name,
+        )
+
+    @computed_field
+    @property
+    def url_redacted(self) -> str:
+        """URL safe for logging (password hidden)."""
+        return self.url_parsed.render_as_string(hide_password=True)
+
+
+class DatabaseExtension(BaseExtension, HasCLI):
+    """
+    Database extension providing AsyncSession via svcs.
+
+    Registers:
+        - AsyncEngine: The SQLAlchemy async engine
+        - async_sessionmaker: Factory for creating sessions
+        - AsyncSession: Request-scoped session (via factory)
+
+    CLI Commands:
+        - db upgrade [revision]: Run migrations
+        - db downgrade [revision]: Rollback migrations
+        - db revision -m "message": Create new migration
+        - db current: Show current revision
+        - db history: Show migration history
+        - db check: Check database connectivity
+
+    Configuration (env or pyproject.toml [tool.cuneus.database]):
+        DATABASE_URL: Connection string
+        DATABASE_POOL_SIZE: Connection pool size (default: 5)
+        DATABASE_POOL_MAX_OVERFLOW: Max overflow connections (default: 10)
+        DATABASE_POOL_RECYCLE: Connection recycle time in seconds (default: 3600)
+        DATABASE_ECHO: Echo SQL statements (default: false)
+        DATABASE_ALEMBIC_CONFIG: Path to alembic.ini (default: alembic.ini)
+    """
+
+    _session_factory: async_sessionmaker[AsyncSession]
+    _engine: AsyncEngine
+
+    def __init__(self, settings: DatabaseSettings | None = None):
+        self.settings = settings or DatabaseSettings()
+
+    @asynccontextmanager
+    async def register(
+        self, registry: svcs.Registry, app: FastAPI
+    ) -> AsyncIterator[dict[str, Any]]:
+        self._engine = create_async_engine(
+            self.settings.url_parsed,
+            # pool_size=self.settings.pool_size,
+            # max_overflow=self.settings.pool_max_overflow,
+            pool_recycle=self.settings.pool_recycle,
+            echo=self.settings.echo,
+        )
+
+        self._session_factory = async_sessionmaker(
+            self._engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+
+        registry.register_value(AsyncEngine, self._engine, ping=self._check)
+        registry.register_value(async_sessionmaker, self._session_factory)
+
+        @asynccontextmanager
+        async def session_factory() -> AsyncIterator[AsyncSession]:
+            async with self._session_factory() as session:
+                try:
+                    yield session
+                    await session.commit()
+                except Exception:
+                    await session.rollback()
+                    raise
+
+        registry.register_factory(AsyncSession, session_factory)
+
+        logger.info("Database started", extra={"url": self.settings.url_redacted})
+
+        try:
+            yield {
+                "db_engine": self._engine,
+                "db_session_factory": self._session_factory,
+            }
+        finally:
+            await self._engine.dispose()
+            logger.info("Database shutdown")
+
+    async def _check(self):
+        engine = create_async_engine(self.settings.url_parsed)
+        try:
+            async with engine.connect() as conn:
+                await conn.execute(text("SELECT 1"))
+        finally:
+            await engine.dispose()
+
+    def register_cli(self, cli_group: click.Group) -> None:
+        settings = self.settings
+
+        @cli_group.group()
+        def db():
+            """Database management commands."""
+            pass
+
+        @db.command()
+        @click.argument("revision", default="head")
+        def upgrade(revision: str):
+            """Upgrade database to revision (default: head)."""
+            _run_alembic_cmd("upgrade", settings.alembic_config, revision=revision)
+
+        @db.command()
+        @click.argument("revision", default="-1")
+        def downgrade(revision: str):
+            """Downgrade database to revision (default: -1)."""
+            _run_alembic_cmd("downgrade", settings.alembic_config, revision=revision)
+
+        @db.command()
+        @click.option("-m", "--message", required=True, help="Migration message")
+        @click.option("--autogenerate/--no-autogenerate", default=True)
+        def revision(message: str, autogenerate: bool):
+            """Create a new migration revision."""
+            _run_alembic_cmd(
+                "revision",
+                settings.alembic_config,
+                message=message,
+                autogenerate=autogenerate,
+            )
+
+        @db.command()
+        def current():
+            """Show current database revision."""
+            _run_alembic_cmd("current", settings.alembic_config)
+
+        @db.command()
+        def history():
+            """Show migration history."""
+            _run_alembic_cmd("history", settings.alembic_config)
+
+        @db.command()
+        @click.argument("template", default="async")
+        def init():
+            """
+            Create a new alembic setup by default this will use the async template
+            """
+
+        @db.command()
+        @click.pass_context
+        def check(ctx: click.Context):
+            """Check database connectivity."""
+            import asyncio
+
+            async def _check():
+                engine = create_async_engine(settings.url_parsed)
+                try:
+                    async with engine.connect() as conn:
+                        await conn.execute(text("SELECT 1"))
+                    click.echo("✓ Database connection OK")
+                except Exception as e:
+                    print(e)
+                    click.echo(f"✗ Database connection failed: {e}", err=True)
+                    ctx.exit(1)
+                finally:
+                    await engine.dispose()
+
+            asyncio.run(_check())
+
+
+def _run_alembic_cmd(
+    cmd: str,
+    config_path: Path,
+    revision: str | None = None,
+    message: str | None = None,
+    autogenerate: bool = False,
+) -> None:
+    """Run an alembic command."""
+    from alembic import command
+    from alembic.config import Config
+
+    if not config_path.exists():
+        raise click.ClickException(f"Alembic config not found: {config_path}")
+
+    cfg = Config(str(config_path))
+
+    match cmd:
+        case "upgrade":
+            command.upgrade(cfg, revision or "head")
+        case "downgrade":
+            command.downgrade(cfg, revision or "-1")
+        case "revision":
+            command.revision(cfg, message=message, autogenerate=autogenerate)
+        case "current":
+            command.current(cfg)
+        case "history":
+            command.history(cfg)
+        case _:
+            raise click.ClickException(f"Unknown command: {cmd}")

{cuneus-0.2.9 → cuneus-0.2.10}/src/cuneus/ext/health.py

@@ -37,9 +37,7 @@ class HealthResponse(BaseModel):
 
 
 @health_router.get("", response_model=HealthResponse)
-async def health(
-    services: svcs.fastapi.DepContainer, request: Request
-) -> HealthResponse:
+async def health(services: svcs.fastapi.DepContainer, request: Request) -> HealthResponse:
     """Full health check - pings all registered services."""
     pings = services.get_pings()