cuneus 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

cuneus/{middleware → core}/logging.py

@@ -4,17 +4,21 @@ Structured logging with structlog and request context.
 
 from __future__ import annotations
 
+from contextvars import ContextVar
 import logging
 import time
 import uuid
-from typing import Any, AsyncIterator
+from typing import Any, Awaitable, Callable, MutableMapping
 
 import structlog
 import svcs
 from fastapi import FastAPI, Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.middleware import Middleware
+from starlette.types import ASGIApp, Scope, Send, Receive
 
-from cuneus.core.application import BaseExtension, Settings
+from .extensions import BaseExtension
+from .settings import Settings
 
 
 class LoggingExtension(BaseExtension):
@@ -34,8 +38,8 @@ class LoggingExtension(BaseExtension):
         )
     """
 
-    def __init__(self, settings: Settings) -> None:
-        self.settings = settings
+    def __init__(self, settings: Settings | None = None) -> None:
+        self.settings = settings or Settings()
         self._configure_structlog()
 
     def _configure_structlog(self) -> None:
@@ -52,10 +56,9 @@ class LoggingExtension(BaseExtension):
             structlog.processors.UnicodeDecoder(),
         ]
 
+        renderer: structlog.types.Processor = structlog.dev.ConsoleRenderer(colors=True)
         if settings.log_json:
             renderer = structlog.processors.JSONRenderer()
-        else:
-            renderer = structlog.dev.ConsoleRenderer(colors=True)
 
         # Configure structlog
         structlog.configure(
@@ -92,6 +95,14 @@ class LoggingExtension(BaseExtension):
         # app.add_middleware(RequestLoggingMiddleware)
         return {}
 
+    def middleware(self) -> list[Middleware]:
+        return [
+            Middleware(
+                LoggingMiddleware,
+                header_name=self.settings.request_id_header,
+            ),
+        ]
+
 
 class LoggingMiddleware(BaseHTTPMiddleware):
     """
@@ -102,8 +113,14 @@ class LoggingMiddleware(BaseHTTPMiddleware):
     - Adds request_id to response headers
     """
 
-    async def dispatch(self, request: Request, call_next) -> Response:
-        request_id = request.headers.get("X-Request-ID") or str(uuid.uuid4())[:8]
+    def __init__(self, app: ASGIApp, header_name: str = "X-Request-ID") -> None:
+        self.header_name = header_name
+        super().__init__(app)
+
+    async def dispatch(
+        self, request: Request, call_next: Callable[..., Awaitable[Response]]
+    ) -> Response:
+        request_id = request.headers.get(self.header_name) or str(uuid.uuid4())[:8]
 
         structlog.contextvars.clear_contextvars()
         structlog.contextvars.bind_contextvars(
@@ -127,7 +144,7 @@ class LoggingMiddleware(BaseHTTPMiddleware):
                 duration_ms=round(duration_ms, 2),
             )
 
-            response.headers["X-Request-ID"] = request_id
+            response.headers[self.header_name] = request_id
             return response
 
         except Exception:
@@ -136,6 +153,45 @@ class LoggingMiddleware(BaseHTTPMiddleware):
             structlog.contextvars.clear_contextvars()
 
 
+# Used by httpx for request ID propagation
+request_id_ctx: ContextVar[str | None] = ContextVar("request_id", default=None)
+
+
+class RequestIDMiddleware:
+    def __init__(self, app: ASGIApp, header_name: str = "X-Request-ID") -> None:
+        self.app = app
+        self.header_name = header_name
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        headers = dict(scope.get("headers", []))
+        request_id = headers.get(
+            self.header_name.lower().encode(), str(uuid.uuid4())[:8].encode()
+        ).decode()
+
+        if "state" not in scope:
+            scope["state"] = {}
+        scope["state"]["request_id"] = request_id
+
+        # Set contextvar for use in HTTP clients
+        token = request_id_ctx.set(request_id)
+
+        async def send_with_request_id(message: MutableMapping[str, Any]) -> None:
+            if message["type"] == "http.response.start":
+                headers = list(message.get("headers", []))
+                headers.append((self.header_name.encode(), request_id.encode()))
+                message["headers"] = headers
+            await send(message)
+
+        try:
+            await self.app(scope, receive, send_with_request_id)
+        finally:
+            request_id_ctx.reset(token)
+
+
 # === Public API ===
 
 
@@ -147,7 +203,7 @@ def get_logger(**initial_context: Any) -> structlog.stdlib.BoundLogger:
         log = get_logger()
         log.info("user logged in", user_id=123)
     """
-    log = structlog.get_logger()
+    log = structlog.stdlib.get_logger()
     if initial_context:
         log = log.bind(**initial_context)
     return log

cuneus/core/settings.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import logging
+from pydantic_settings import (
+    BaseSettings,
+    PydanticBaseSettingsSource,
+    PyprojectTomlConfigSettingsSource,
+    SettingsConfigDict,
+)
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TOOL_NAME = "cuneus"
+
+
+class CuneusBaseSettings(BaseSettings):
+    """
+    Base settings that loads from:
+    1. pyproject.toml [tool.cuneus] (lowest priority)
+    2. .env file
+    3. Environment variables (highest priority)
+    """
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            init_settings,
+            PyprojectTomlConfigSettingsSource(settings_cls),
+            env_settings,
+            dotenv_settings,
+            file_secret_settings,
+        )
+
+
+class Settings(CuneusBaseSettings):
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="allow",
+        pyproject_toml_depth=2,
+        pyproject_toml_table_header=("tool", DEFAULT_TOOL_NAME),
+    )
+
+    app_name: str = "app"
+    app_module: str = "app.main:app"
+    cli_module: str = "app.main:cli"
+    debug: bool = False
+    version: str | None = None
+
+    # logging
+    log_level: str = "INFO"
+    log_json: bool = False
+    log_server_errors: bool = True
+    request_id_header: str = "X-Request-ID"
+
+    # health
+    health_enabled: bool = True
+    health_prefix: str = "/healthz"

cuneus/ext/health.py

@@ -9,10 +9,11 @@ from typing import Any
 
 import structlog
 import svcs
-from fastapi import APIRouter, FastAPI, Request
+from fastapi import APIRouter, FastAPI
 from pydantic import BaseModel
 
-from cuneus.core.application import BaseExtension, Settings
+from ..core.extensions import BaseExtension
+from ..core.settings import Settings
 
 log = structlog.get_logger()
 
@@ -53,8 +54,8 @@ class HealthExtension(BaseExtension):
         )
     """
 
-    def __init__(self, settings: Settings) -> None:
-        self.settings = settings
+    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]:
         if not self.settings.health_enabled:

{cuneus-0.2.1.dist-info → cuneus-0.2.2.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: cuneus
-Version: 0.2.1
+Version: 0.2.2
 Summary: ASGI application wrapper
 Project-URL: Homepage, https://github.com/rmyers/cuneus
 Project-URL: Documentation, https://github.com/rmyers/cuneus#readme
 Project-URL: Repository, https://github.com/rmyers/cuneus
 Author-email: Robert Myers <robert@julython.org>
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: click>=8.0
 Requires-Dist: fastapi>=0.109.0
 Requires-Dist: pydantic-settings>=2.0
@@ -62,26 +62,26 @@ pip install cuneus
 ## Quick Start
 
 ```python
-# app.py
+# app/main.py
 from fastapi import FastAPI
-from cuneus import build_lifespan, Settings
-from cuneus.middleware.logging import LoggingMiddleware
+from cuneus import build_app, Settings
 
 from myapp.extensions import DatabaseExtension
 
-settings = Settings()
-lifespan = build_lifespan(
-    settings,
-    DatabaseExtension(settings),
+class MyAppSettings(Settings):
+    my_mood: str = "extatic"
+
+app, cli = build_app(
+    DatabaseExtension,
+    settings=MyAppSettings(),
 )
 
-app = FastAPI(lifespan=lifespan, title="My App", version="1.0.0")
+app.include_router(my_router)
 
-# Add middleware directly to FastAPI
-app.add_middleware(LoggingMiddleware)
+__all__ = ["app", "cli"]
 ```
 
-That's it. Extensions handle their lifecycle, FastAPI handles the rest.
+That's it. Extensions handle their lifecycle, registration, and middleware.
 
 ## Creating Extensions
 
@@ -115,6 +115,14 @@ class DatabaseExtension(BaseExtension):
     async def shutdown(self, app: FastAPI) -> None:
         if self.engine:
             await self.engine.dispose()
+
+    def middleware(self) -> list[Middleware]:
+        return [Middleware(DatabaseLoggingMiddleware, level=INFO)]
+
+    def register_cli(self, app_cli: click.Group) -> None:
+        @app_cli.command()
+        @click.option("--workers", default=1, type=int, help="Number of workers")
+        def blow_up_db(workers: int): ...
 ```
 
 For full control, override `register()` directly:
@@ -195,6 +203,8 @@ Base class with `startup()` and `shutdown()` hooks:
 
 - `startup(registry, app) -> dict[str, Any]`: Setup resources, return state
 - `shutdown(app) -> None`: Cleanup resources
+- `middleware() -> list[Middleware]`: Optional middleware to configure
+- `register_cli(group) -> None`: Optional hook to add click commands
 
 ### `Extension` Protocol
 
@@ -213,8 +223,7 @@ def register(self, registry: svcs.Registry, app: FastAPI) -> AsyncContextManager
 
 ## Why cuneus?
 
-- **Simple** — one function, `build_lifespan()`, does what you need
-- **No magic** — middleware added directly to FastAPI, not hidden
+- **Simple** — one function, `build_app()`, does what you need
 - **Testable** — registry exposed via `lifespan.registry`
 - **Composable** — extensions are just async context managers
 - **Built on svcs** — proper dependency injection, not global state

cuneus-0.2.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+cuneus/__init__.py,sha256=JJ3nZ4757GU9KKuurxP1FfJSdSVrcO-xaorLFSvUJ5E,1211
+cuneus/cli.py,sha256=pdtoGmjn8NFuOcxaqAlBJfrkLOZI9fS0NEWo5WVSaUo,3480
+cuneus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuneus/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuneus/core/application.py,sha256=MlVjGWjuKGut5YaIP8BdjuCXFi-tpCwhL4g6N5NRL4U,3773
+cuneus/core/execptions.py,sha256=beQE3gD-14BUK4Se6yE2J2U92xgr0yarVmVeibkudxs,5753
+cuneus/core/extensions.py,sha256=wdsn5DSHSrzduQwwLgKr38hgvQJi6zsh3MNnE1mINF0,2586
+cuneus/core/logging.py,sha256=OlcWxBCLDqBORzTXZXKlMc_rGD8OkfOBfHgSwEpMCM4,6778
+cuneus/core/settings.py,sha256=PaYXQ_ubeSt3AFpxNNErii-h1_ehHYPrajFWRT42mTI,1703
+cuneus/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuneus/ext/health.py,sha256=5dWVVEPFL1tWFBhQwZv8C-IvZRzg28V-4sk_g1jJ0vc,3854
+cuneus-0.2.2.dist-info/METADATA,sha256=ItNul_KF_Lgjh2zU9cCm4SAqSdAR-Nqe7XDyGsQhB08,6794
+cuneus-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cuneus-0.2.2.dist-info/entry_points.txt,sha256=tzPgom-_UkpP_uLKv3V_XyoIsKg84FBAc9ddjYl0W0Y,43
+cuneus-0.2.2.dist-info/RECORD,,