cuneus 0.2.7__tar.gz → 0.2.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cuneus
-Version: 0.2.7
+Version: 0.2.9
 Summary: ASGI application wrapper
 Project-URL: Homepage, https://github.com/rmyers/cuneus
 Project-URL: Documentation, https://github.com/rmyers/cuneus#readme

cuneus-0.2.9/examples/my_app/main.py

@@ -0,0 +1,6 @@
+from cuneus import build_app
+
+
+app, cli, lifespan = build_app()
+
+__all__ = ["app", "cli", "lifespan"]

cuneus-0.2.9/examples/pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "test-project"
+version = "0.0.1"
+
+[tool.cuneus]
+app_module = "my_app.main:app"
+cli_module = "my_app.main:cli"

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

@@ -1,6 +1,6 @@
 [project]
 name = "cuneus"
-version = "0.2.7"
+version = "0.2.9"
 description = "ASGI application wrapper"
 readme = "README.md"
 authors = [{ name = "Robert Myers", email = "robert@julython.org" }]

cuneus-0.2.9/src/cuneus/cli.py

@@ -0,0 +1,53 @@
+"""Cuneus CLI entry point."""
+
+from typing import Any, cast
+
+import click
+
+from .core.settings import Settings, ensure_project_in_path
+from .utils import import_from_string
+
+
+def get_user_cli(config: Settings = Settings()) -> click.Group | None:
+    """Load CLI from config."""
+    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
+        )
+        return None
+
+
+class CuneusCLI(click.Group):
+    """Delegates to the app's CLI from config."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._user_cli: click.Group | None = None
+        self._user_cli_loaded = False
+
+    @property
+    def user_cli(self) -> click.Group | None:
+        if not self._user_cli_loaded:
+            self._user_cli = get_user_cli()
+            self._user_cli_loaded = True
+        return self._user_cli
+
+    def list_commands(self, ctx: click.Context) -> list[str]:
+        if self.user_cli:
+            return self.user_cli.list_commands(ctx)
+        return []
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        if self.user_cli:
+            return self.user_cli.get_command(ctx, cmd_name)
+        return None
+
+
+ensure_project_in_path()
+main = CuneusCLI(help="Cuneus CLI - FastAPI application framework")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -19,8 +19,9 @@ from starlette.middleware import Middleware
 from .settings import Settings
 from .exceptions import ExceptionExtension
 from .logging import LoggingExtension
-from .extensions import Extension, HasCLI, HasExceptionHandler, HasMiddleware
+from .extensions import Extension, HasCLI, HasExceptionHandler, HasMiddleware, HasRoutes
 from ..ext.health import HealthExtension
+from ..ext.server import ServerExtension
 
 logger = structlog.stdlib.get_logger("cuneus")
 
@@ -30,6 +31,7 @@ DEFAULTS = (
     LoggingExtension,
     HealthExtension,
     ExceptionExtension,
+    ServerExtension,
 )
 
 
@@ -56,7 +58,7 @@ def build_app(
     settings: Settings | None = None,
     include_defaults: bool = True,
     **fastapi_kwargs: Any,
-) -> tuple[FastAPI, click.Group]:
+) -> tuple[FastAPI, click.Group, svcs.fastapi.lifespan]:
     """
     Build a FastAPI with extensions preconfigured.
 
@@ -93,12 +95,6 @@ def build_app(
 
     all_extensions = [_instantiate_extension(ext, settings) for ext in all_inputs]
 
-    @click.group()
-    @click.pass_context
-    def app_cli(ctx: click.Context) -> None:
-        """Application CLI."""
-        ctx.ensure_object(dict)
-
     @svcs.fastapi.lifespan
     @asynccontextmanager
     async def lifespan(
@@ -121,6 +117,7 @@ def build_app(
 
     # Parse extensions for middleware and cli commands
     middleware: list[Middleware] = []
+    app_cli = click.Group()
 
     for ext in all_extensions:
         ext_name = ext.__class__.__name__
@@ -139,5 +136,8 @@ def build_app(
         if isinstance(ext, HasExceptionHandler):
             logger.debug(f"Loading exception handlers from {ext_name}")
             ext.add_exception_handler(app)
+        if isinstance(ext, HasRoutes):
+            logger.debug(f"Loading routes from {ext_name}")
+            ext.add_routes(app)
 
-    return app, app_cli
+    return app, app_cli, lifespan

{cuneus-0.2.7 → cuneus-0.2.9}/src/cuneus/core/extensions.py

@@ -67,6 +67,13 @@ class HasExceptionHandler(Protocol):
     def add_exception_handler(self, app: FastAPI) -> None: ...  # pragma: no cover
 
 
+@runtime_checkable
+class HasRoutes(Protocol):
+    """Extension that provides routes."""
+
+    def add_routes(self, app: FastAPI) -> None: ...  # pragma: no cover
+
+
 class BaseExtension:
     """
     Base class for extensions with explicit startup/shutdown hooks.

{cuneus-0.2.7 → cuneus-0.2.9}/src/cuneus/core/logging.py

@@ -5,6 +5,7 @@ Structured logging with structlog and request context.
 from __future__ import annotations
 
 import logging
+import shutil
 import time
 import uuid
 from typing import Any, Awaitable, Callable
@@ -36,9 +37,14 @@ def configure_structlog(settings: Settings | None = None) -> None:
         structlog.processors.UnicodeDecoder(),
     ]
 
-    renderer: structlog.types.Processor = structlog.dev.ConsoleRenderer(colors=True)
-    if log_settings.log_json:  # pragma: no cover
-        renderer = structlog.processors.JSONRenderer()
+    renderer = structlog.processors.JSONRenderer()
+
+    if not log_settings.log_json:  # pragma: no branch
+        term_width = shutil.get_terminal_size().columns
+        pad_event = term_width - 36
+        renderer: structlog.types.Processor = structlog.dev.ConsoleRenderer(
+            colors=True, pad_event_to=pad_event
+        )
 
     # Configure structlog
     structlog.configure(
@@ -84,10 +90,6 @@ class LoggingExtension(BaseExtension):
         self.settings = settings or Settings()
         configure_structlog(settings)
 
-    async def startup(self, registry: svcs.Registry, app: FastAPI) -> dict[str, Any]:
-        # app.add_middleware(RequestLoggingMiddleware)
-        return {}
-
     def middleware(self) -> list[Middleware]:
         return [
             Middleware(

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

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-import logging
+import pathlib
+import sys
 from pydantic_settings import (
     BaseSettings,
     PydanticBaseSettingsSource,
@@ -8,8 +9,6 @@ from pydantic_settings import (
     SettingsConfigDict,
 )
 
-logger = logging.getLogger(__name__)
-
 DEFAULT_TOOL_NAME = "cuneus"
 
 
@@ -64,3 +63,21 @@ class Settings(CuneusBaseSettings):
     # health
     health_enabled: bool = True
     health_prefix: str = "/healthz"
+
+    @classmethod
+    def get_project_root(cls) -> pathlib.Path:
+        """
+        Get the project root by inspecting where pydantic-settings
+        found the pyproject.toml file.
+        """
+        source = PyprojectTomlConfigSettingsSource(
+            cls,
+        )
+        return source.toml_file_path.parent
+
+
+def ensure_project_in_path() -> None:
+    """Add project root to sys.path if not already present."""
+    project_root = str(Settings.get_project_root())
+    if project_root not in sys.path:  # pragma: no branch
+        sys.path.insert(0, project_root)

cuneus-0.2.9/src/cuneus/ext/health.py

@@ -0,0 +1,128 @@
+"""
+Health check endpoints using svcs ping capabilities.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+import structlog
+import svcs
+from fastapi import APIRouter, FastAPI, Request
+from pydantic import BaseModel
+
+from ..core.extensions import BaseExtension
+from ..core.settings import Settings
+
+log = structlog.get_logger()
+health_router = APIRouter()
+
+
+class HealthStatus(str, Enum):
+    HEALTHY = "healthy"
+    UNHEALTHY = "unhealthy"
+
+
+class ServiceHealth(BaseModel):
+    name: str
+    status: HealthStatus
+    message: str | None = None
+
+
+class HealthResponse(BaseModel):
+    status: HealthStatus
+    version: str | None = None
+    services: list[ServiceHealth] = []
+
+
+@health_router.get("", response_model=HealthResponse)
+async def health(
+    services: svcs.fastapi.DepContainer, request: Request
+) -> HealthResponse:
+    """Full health check - pings all registered services."""
+    pings = services.get_pings()
+
+    _services: list[ServiceHealth] = []
+    overall_healthy = True
+
+    for ping in pings:
+        try:
+            await ping.aping()
+            _services.append(
+                ServiceHealth(
+                    name=ping.name,
+                    status=HealthStatus.HEALTHY,
+                )
+            )
+        except Exception as e:
+            log.warning("health_check_failed", service=ping.name, error=str(e))
+            _services.append(
+                ServiceHealth(
+                    name=ping.name,
+                    status=HealthStatus.UNHEALTHY,
+                    message=str(e),
+                )
+            )
+            overall_healthy = False
+
+    return HealthResponse(
+        status=(HealthStatus.HEALTHY if overall_healthy else HealthStatus.UNHEALTHY),
+        version=getattr(request.state, "version", "NA"),
+        services=_services,
+    )
+
+
+@health_router.get("/live")
+async def liveness() -> dict[str, str]:
+    """Liveness probe - is the process running?"""
+    return {"status": "ok"}
+
+
+@health_router.get("/ready")
+async def readiness(services: svcs.fastapi.DepContainer) -> dict[str, str]:
+    """Readiness probe - can we serve traffic?"""
+    from fastapi import HTTPException
+
+    pings = services.get_pings()
+
+    for ping in pings:
+        try:
+            await ping.aping()
+        except Exception as e:
+            log.warning("readiness_check_failed", service=ping.name, error=str(e))
+            raise HTTPException(status_code=503, detail=f"{ping.name} unhealthy")
+
+    return {"status": "ok"}
+
+
+class HealthExtension(BaseExtension):
+    """
+    Health check extension using svcs pings.
+
+    Adds:
+        GET /healthz       - Full health check using svcs pings
+        GET /healthz/live  - Liveness probe (always 200)
+        GET /healthz/ready - Readiness probe (503 if unhealthy)
+
+    Settings:
+        - `health_enabled`: bool to disable health routes, default True
+        - `health_prefix`: prefix to include routes default: '/healthz'
+        - `version`: used to display in the response
+    """
+
+    def __init__(self, settings: Settings | None = None) -> None:
+        self.settings = settings or Settings()
+
+    async def startup(self, registry: svcs.Registry, app: FastAPI) -> dict[str, Any]:
+        state = await super().startup(registry, app)
+        state["version"] = self.settings.version
+        return state
+
+    def add_routes(self, app: FastAPI) -> None:
+        if self.settings.health_enabled:
+            app.include_router(
+                health_router,
+                prefix=self.settings.health_prefix,
+                tags=["health"],
+            )

cuneus-0.2.9/src/cuneus/ext/server.py

@@ -0,0 +1,54 @@
+import click
+
+from ..core.extensions import BaseExtension
+from ..utils import import_from_string
+
+
+class ServerExtension(BaseExtension):
+    """Provides dev/prod/routes CLI commands."""
+
+    def register_cli(self, cli_group: click.Group) -> None:
+        settings = self.settings
+
+        @cli_group.command()
+        @click.option("--host", default="0.0.0.0", help="Bind host")
+        @click.option("--port", default=8000, type=int, help="Bind port")
+        def dev(host: str, port: int) -> None:
+            """Run the application in development mode with reload."""
+            import uvicorn
+
+            uvicorn.run(
+                settings.app_module,
+                host=host,
+                port=port,
+                reload=True,
+                log_config=None,
+                server_header=False,
+            )
+
+        @cli_group.command()
+        @click.option("--host", default="0.0.0.0", help="Bind host")
+        @click.option("--port", default=8000, type=int, help="Bind port")
+        @click.option("--workers", default=1, type=int, help="Number of workers")
+        def prod(host: str, port: int, workers: int) -> None:
+            """Run the application in production mode."""
+            import uvicorn
+
+            uvicorn.run(
+                settings.app_module,
+                host=host,
+                port=port,
+                workers=workers,
+                log_config=None,
+                server_header=False,
+            )
+
+        @cli_group.command()
+        def routes() -> None:
+            """List all registered routes."""
+            app = import_from_string(settings.app_module)
+
+            for route in app.routes:
+                if hasattr(route, "methods"):  # pragma: no branch
+                    methods = ",".join(route.methods - {"HEAD", "OPTIONS"})
+                    click.echo(f"{methods:8} {route.path}")

cuneus-0.2.9/src/cuneus/utils.py

@@ -0,0 +1,14 @@
+import importlib
+import typing
+
+
+def import_from_string(import_str: str) -> typing.Any:
+    """Import an object from a module:attribute string."""
+    module_path, _, attr = import_str.partition(":")
+    if not attr:
+        raise ValueError(
+            f"module_path missing function {import_str} expecting 'module.path:name'"
+        )
+
+    module = importlib.import_module(module_path)
+    return getattr(module, attr)

cuneus-0.2.9/tests/cli/test_cli.py

@@ -0,0 +1,145 @@
+# tests/cli/test_cli_integration.py
+"""Integration tests for the cuneus CLI."""
+
+import sys
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+
+TEST_APP_DIR = Path(__file__).parent / "testapp"
+
+
+@pytest.fixture
+def cli_runner():
+    return CliRunner()
+
+
+@pytest.fixture
+def test_app(cli_runner, tmp_path):
+    """Set up isolated test app environment."""
+    import shutil
+
+    with cli_runner.isolated_filesystem(temp_dir=tmp_path):
+        # Copy pyproject.toml, main.py, etc. to project root (cwd)
+        shutil.copytree(TEST_APP_DIR, Path.cwd(), dirs_exist_ok=True)
+
+        for mod in list(sys.modules):
+            if mod.startswith(("main", "cuneus.cli")):
+                del sys.modules[mod]
+
+        yield Path.cwd()
+
+
+class TestCLIDiscovery:
+    def test_discovers_app_commands(self, cli_runner, test_app):
+        from cuneus.cli import CuneusCLI
+
+        cli = CuneusCLI()
+        commands = cli.list_commands(None)  # type: ignore
+
+        assert "dev" in commands
+        assert "prod" in commands
+        assert "routes" in commands
+        assert "custom" in commands
+
+    def test_custom_command_executes(self, cli_runner, test_app):
+        from cuneus.cli import CuneusCLI
+
+        cli = CuneusCLI()
+        result = cli_runner.invoke(cli, ["custom"])
+
+        assert result.exit_code == 0
+        assert "custom command executed" in result.output
+
+    def test_help_shows_all_commands(self, cli_runner, test_app):
+        from cuneus.cli import CuneusCLI
+
+        cli = CuneusCLI()
+        result = cli_runner.invoke(cli, ["--help"])
+
+        assert result.exit_code == 0
+        assert "dev" in result.output
+        assert "custom" in result.output
+
+
+class TestBuiltInCommands:
+    def test_routes_command_lists_routes(self, cli_runner, test_app):
+        from cuneus.cli import CuneusCLI
+
+        cli = CuneusCLI()
+        result = cli_runner.invoke(cli, ["routes"])
+
+        assert result.exit_code == 0
+        assert "/hello" in result.output
+        assert "/healthz" in result.output
+
+    def test_dev_command_starts_uvicorn(self, cli_runner, test_app, mocker):
+        mock_run = mocker.patch("uvicorn.run")
+
+        from cuneus.cli import CuneusCLI
+
+        cli = CuneusCLI()
+        result = cli_runner.invoke(
+            cli, ["dev", "--host", "127.0.0.1", "--port", "9000"]
+        )
+
+        assert result.exit_code == 0
+        mock_run.assert_called_once()
+        call_kwargs = mock_run.call_args.kwargs
+        assert call_kwargs["host"] == "127.0.0.1"
+        assert call_kwargs["port"] == 9000
+        assert call_kwargs["reload"] is True
+
+    def test_prod_command_starts_uvicorn(self, cli_runner, test_app, mocker):
+        mock_run = mocker.patch("uvicorn.run")
+
+        from cuneus.cli import CuneusCLI
+
+        cli = CuneusCLI()
+        result = cli_runner.invoke(cli, ["prod", "--workers", "4"])
+
+        assert result.exit_code == 0
+        mock_run.assert_called_once()
+        call_kwargs = mock_run.call_args.kwargs
+        assert call_kwargs["workers"] == 4
+
+
+class TestCLIFromSubdirectory:
+    def test_discovers_pyproject_from_subdirectory(
+        self, cli_runner: CliRunner, test_app
+    ):
+        import os
+
+        subdir = test_app / "src" / "nested"
+        subdir.mkdir(parents=True)
+        os.chdir(subdir)
+
+        for mod in list(sys.modules):
+            if mod.startswith(("main", "cuneus.cli")):
+                del sys.modules[mod]
+
+        from cuneus.cli import CuneusCLI
+
+        cli = CuneusCLI()
+        commands = cli.list_commands(None)  # type: ignore
+
+        assert "custom" in commands
+
+
+class TestCLIMissingConfig:
+    def test_handles_missing_pyproject(self, cli_runner, tmp_path):
+        with cli_runner.isolated_filesystem(temp_dir=tmp_path):
+            for mod in list(sys.modules):
+                if mod.startswith("cuneus.cli"):
+                    del sys.modules[mod]
+
+            from cuneus.cli import CuneusCLI
+
+            cli = CuneusCLI()
+            result = cli_runner.invoke(cli, ["--help"])
+
+            assert result.exit_code == 0
+            result = cli_runner.invoke(cli, ["dev"])
+            assert result.exit_code == 2

cuneus-0.2.9/tests/cli/testapp/main.py

@@ -0,0 +1,23 @@
+# tests/cli/testapp/main.py
+"""Test application for CLI integration tests."""
+
+import click
+from cuneus import build_app, BaseExtension
+
+
+class TestExtension(BaseExtension):
+    pass
+
+
+app, cli, lifespan = build_app(TestExtension)
+
+
+@cli.command()
+def custom():
+    """A custom user command."""
+    click.echo("custom command executed")
+
+
+@app.get("/hello")
+def hello():
+    return {"message": "hello"}

cuneus-0.2.9/tests/cli/testapp/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = 'testapp'
+version = '0.0.1'
+
+
+[tool.cuneus]
+app_name = "Testy McTester"
+app_module = "main:app"
+cli_module = "main:cli"