csrd-context 0.1.0__tar.gz

csrd_context-0.1.0/.gitignore

@@ -0,0 +1,217 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+/env/
+/venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+*.db
+
+
+# Import linter cache
+.import_linter_cache/
+
+# IDE
+.idea/
+.idea/*

csrd_context-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: csrd-context
+Version: 0.1.0
+Summary: Request context, header utilities, and logging middleware for FastAPI
+Project-URL: Repository, https://github.com/csrd-api/fastapi-common
+Project-URL: Documentation, https://github.com/csrd-api/fastapi-common/tree/main/packages/context
+Project-URL: Changelog, https://github.com/csrd-api/fastapi-common/blob/main/CHANGELOG.md
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: csrd-models
+Requires-Dist: fastapi<1,>=0.115
+Requires-Dist: starlette>=0.36

csrd_context-0.1.0/README.md

@@ -0,0 +1,25 @@
+# csrd-context
+
+Request context, header utilities, and logging middleware for FastAPI.
+
+**Package**: `csrd.context` · **Import**: `from csrd.context import ...`
+
+## What's included
+
+- Framework-agnostic context variable system (headers, path params, query params, API version)
+- `RequestContextMiddleware` — captures request headers into context (raw ASGI, streaming-safe)
+- `HTTPLoggingMiddleware` — structured HTTP request/response logging (raw ASGI, streaming-safe)
+- Platform context variables (`user_info_context`, `hit_id_context`, `app_id_context`)
+- `get_headers()`, `get_hit_id()`, `get_app_id()` — accessors for the current request context
+
+## Installation
+
+This package is part of the `fastapi-common` monorepo. Install via git:
+
+```bash
+uv pip install "csrd-context @ git+ssh://git@github.com/csrd-api/fastapi-common.git#subdirectory=packages/context"
+```
+
+## Dependencies
+
+- `csrd-models` (Tier 1 — no other `csrd.*` sibling dependencies)

csrd_context-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "csrd-context"
+version = "0.1.0"
+description = "Request context, header utilities, and logging middleware for FastAPI"
+license = { text = "MIT" }
+requires-python = ">=3.12"
+dependencies = [
+    "starlette>=0.36",
+    "fastapi>=0.115,<1",
+    "csrd-models",
+]
+
+[tool.uv.sources]
+csrd-models = { workspace = true }
+
+[project.urls]
+Repository = "https://github.com/csrd-api/fastapi-common"
+Documentation = "https://github.com/csrd-api/fastapi-common/tree/main/packages/context"
+Changelog = "https://github.com/csrd-api/fastapi-common/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/csrd"]

csrd_context-0.1.0/src/csrd/context/__init__.py

@@ -0,0 +1,51 @@
+from ._contextvars import (
+    configure_headers_context_provider,
+    get_api_version,
+    get_app_id,
+    get_headers,
+    get_hit_id,
+    get_path_params,
+    get_query_params,
+    reset_api_version_context,
+    reset_global_configuration,
+    reset_headers_context,
+    reset_path_params,
+    reset_query_params,
+    set_api_version_context,
+    set_headers_context,
+    set_path_params,
+    set_query_params,
+)
+from ._models import PathValue
+from .middleware import HTTPLoggingMiddleware, RequestContextMiddleware
+from .platform import app_id_context, hit_id_context, user_info_context
+
+__all__ = (
+    "HTTPLoggingMiddleware",
+    # Models
+    "PathValue",
+    # Middleware
+    "RequestContextMiddleware",
+    "app_id_context",
+    # Context accessors
+    "configure_headers_context_provider",
+    "get_api_version",
+    "get_app_id",
+    "get_headers",
+    "get_hit_id",
+    "get_path_params",
+    "get_query_params",
+    "hit_id_context",
+    "reset_api_version_context",
+    "reset_global_configuration",
+    "reset_headers_context",
+    "reset_path_params",
+    "reset_query_params",
+    "set_api_version_context",
+    # Context setters
+    "set_headers_context",
+    "set_path_params",
+    "set_query_params",
+    # Platform contextvars
+    "user_info_context",
+)

csrd_context-0.1.0/src/csrd/context/_constants.py

@@ -0,0 +1,6 @@
+"""Header name constants used by context infrastructure."""
+
+APP_ID_HEADER_NAME = "x-client-app-id"
+HIT_ID_HEADER_NAME = "x-client-hit-id"
+
+__all__ = ("APP_ID_HEADER_NAME", "HIT_ID_HEADER_NAME")

csrd_context-0.1.0/src/csrd/context/_contextvars.py

@@ -0,0 +1,184 @@
+import logging
+from collections.abc import Callable
+from contextvars import ContextVar, Token
+from typing import Any
+
+from ._constants import APP_ID_HEADER_NAME, HIT_ID_HEADER_NAME
+from ._models import PathValue
+
+logger = logging.getLogger(__name__)
+
+# Request-scoped context variables and accessors.
+#
+# The ``configure_*`` functions below set module-level state and must be called
+# once during application startup, before any requests are served.
+
+_PATH_CONTEXT_KEY = "path_context"
+_QUERY_CONTEXT_KEY = "query_context"
+_API_VERSION_CONTEXT_KEY = "api_version_context"
+
+_path_context: ContextVar[PathValue | None] = ContextVar(_PATH_CONTEXT_KEY, default=None)
+_query_context: ContextVar[PathValue | None] = ContextVar(_QUERY_CONTEXT_KEY, default=None)
+_api_version_context: ContextVar[str | None] = ContextVar(_API_VERSION_CONTEXT_KEY, default=None)
+
+_headers_getter: Callable[[], Any] | None = None
+_headers_setter: Callable[[Any], Any] | None = None
+_headers_resetter: Callable[[Any], None] | None = None
+_unconfigured_headers_warned = False
+
+
+def reset_global_configuration() -> None:
+    """Reset all module-level configuration to defaults.
+
+    Intended for test teardown to prevent cross-test contamination.
+    """
+    global _headers_getter, _headers_setter, _headers_resetter
+    global _unconfigured_headers_warned
+    _headers_getter = None
+    _headers_setter = None
+    _headers_resetter = None
+    _unconfigured_headers_warned = False
+
+
+def configure_headers_context_provider(
+    *,
+    get_headers: Callable[[], Any],
+    set_headers: Callable[[Any], Any],
+    reset_headers: Callable[[Any], None],
+) -> None:
+    """Configure framework-provided header context accessors.
+
+    Must be called during application startup, before serving requests.
+    """
+
+    global _headers_getter, _headers_setter, _headers_resetter
+    if _headers_getter is not None:
+        logger.warning("Overwriting previously configured headers_context_provider")
+    _headers_getter = get_headers
+    _headers_setter = set_headers
+    _headers_resetter = reset_headers
+
+
+def set_headers_context(headers: Any) -> Any:
+    """Set current request headers in the configured framework context."""
+    if _headers_setter is None:
+        raise RuntimeError(
+            "Headers context not configured. "
+            "Call configure_headers_context_provider() "
+            "before using the context system."
+        )
+    return _headers_setter(headers)
+
+
+def reset_headers_context(token: Any) -> None:
+    """Reset current request headers from the configured framework context."""
+    if token is None:
+        return
+    if _headers_resetter is None:
+        raise RuntimeError(
+            "Headers context not configured. "
+            "Call configure_headers_context_provider() "
+            "before using the context system."
+        )
+    _headers_resetter(token)
+
+
+def set_path_params(path_params: PathValue) -> Token[PathValue | None]:
+    """Store path parameters for the current async context; returns a token for reset."""
+    return _path_context.set(path_params)
+
+
+def reset_path_params(token: Token[PathValue | None]) -> None:
+    """Restore path parameters to their previous value."""
+    _path_context.reset(token)
+
+
+def set_query_params(query_params: PathValue) -> Token[PathValue | None]:
+    """Store query parameters for the current async context; returns a token for reset."""
+    return _query_context.set(query_params)
+
+
+def reset_query_params(token: Token[PathValue | None]) -> None:
+    """Restore query parameters to their previous value."""
+    _query_context.reset(token)
+
+
+def set_api_version_context(version: str | None) -> Token[str | None]:
+    """Store the resolved API version for the current async context."""
+    return _api_version_context.set(version)
+
+
+def reset_api_version_context(token: Token[str | None]) -> None:
+    """Restore the API version to its previous value."""
+    _api_version_context.reset(token)
+
+
+def get_path_params() -> PathValue:
+    """Return request path parameters captured in the current context."""
+    params = _path_context.get()
+    if params is None:
+        return PathValue()
+    return params
+
+
+def get_query_params() -> PathValue:
+    """Return request query parameters captured in the current context."""
+    params = _query_context.get()
+    if params is None:
+        return PathValue()
+    return params
+
+
+def get_api_version() -> str | None:
+    """Return resolved API version for the current request context."""
+    return _api_version_context.get()
+
+
+def get_headers() -> Any:
+    """Return current request headers captured during dispatch."""
+    global _unconfigured_headers_warned
+    if _headers_getter is None:
+        if not _unconfigured_headers_warned:
+            _unconfigured_headers_warned = True
+            logger.warning(
+                "Headers context provider not configured. "
+                "get_headers(), get_app_id(), and get_hit_id() will return empty values. "
+                "Call configure_headers_context_provider() during startup."
+            )
+        return {}
+    headers = _headers_getter()
+    if headers is None:
+        return {}
+    return headers
+
+
+def get_app_id() -> str | None:
+    """Return the current request app-id header value."""
+    val = get_headers().get(APP_ID_HEADER_NAME, None)
+    return str(val) if val is not None else None
+
+
+def get_hit_id() -> str | None:
+    """Return the current request hit-id header value."""
+    val = get_headers().get(HIT_ID_HEADER_NAME, None)
+    return str(val) if val is not None else None
+
+
+__all__ = (
+    "configure_headers_context_provider",
+    "get_api_version",
+    "get_app_id",
+    "get_headers",
+    "get_hit_id",
+    "get_path_params",
+    "get_query_params",
+    "reset_api_version_context",
+    "reset_global_configuration",
+    "reset_headers_context",
+    "reset_path_params",
+    "reset_query_params",
+    "set_api_version_context",
+    "set_headers_context",
+    "set_path_params",
+    "set_query_params",
+)

csrd_context-0.1.0/src/csrd/context/_fastapi_headers.py

@@ -0,0 +1,19 @@
+"""FastAPI-specific context variable for request headers."""
+
+from contextvars import ContextVar
+
+from starlette.datastructures import Headers
+
+HEADERS_KEY = "request_headers"
+
+_EMPTY_HEADERS = Headers()
+
+headers_context: ContextVar[Headers] = ContextVar(HEADERS_KEY, default=_EMPTY_HEADERS)
+
+
+def get_headers() -> Headers:
+    """Return request headers stored in the current context."""
+    return headers_context.get()
+
+
+__all__ = ("HEADERS_KEY", "get_headers", "headers_context")

csrd_context-0.1.0/src/csrd/context/_models.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+
+class PathValue(dict[str, Any]):
+    """Dictionary wrapper that also supports dot-notation for key access."""
+
+    def __getattr__(self, item: str) -> Any:
+        """Return dict values via dot-notation, raising AttributeError for missing keys."""
+        if item.startswith("__"):
+            raise AttributeError(item)
+        try:
+            return self[item]
+        except KeyError:
+            raise AttributeError(f"'{type(self).__name__}' has no key '{item}'") from None
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """Map attribute assignment to dictionary item assignment."""
+        if key.startswith("__"):
+            super().__setattr__(key, value)
+            return
+        self[key] = value
+
+    def __delattr__(self, item: str) -> None:
+        """Map attribute deletion to dictionary item deletion."""
+        if item.startswith("__"):
+            super().__delattr__(item)
+            return
+        try:
+            del self[item]
+        except KeyError as exc:
+            raise AttributeError(item) from exc
+
+
+__all__ = ("PathValue",)

csrd_context-0.1.0/src/csrd/context/middleware/__init__.py

@@ -0,0 +1,4 @@
+from ._logging import REQUEST_SCOPE_KEY, HTTPLoggingMiddleware, RequestScope
+from ._request import RequestContextMiddleware
+
+__all__ = ("REQUEST_SCOPE_KEY", "HTTPLoggingMiddleware", "RequestContextMiddleware", "RequestScope")

csrd_context-0.1.0/src/csrd/context/middleware/_logging.py

@@ -0,0 +1,121 @@
+"""HTTP logging middleware for FastAPI applications.
+
+Implemented as a raw ASGI middleware (no ``BaseHTTPMiddleware``) so that
+``StreamingResponse`` and SSE endpoints are not buffered.
+"""
+
+import logging
+import time
+import uuid
+from collections import defaultdict
+from http import HTTPStatus
+from typing import Any, TypedDict
+
+from starlette.requests import Request
+from starlette.routing import Match
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from csrd.models.claims import UserClaims
+
+logger = logging.getLogger(__name__)
+
+REQUEST_SCOPE_KEY = "__DS__"
+
+
+class RequestScope(TypedDict, total=False):
+    hit_id: str
+    app_id: str
+    user_info: UserClaims | None
+
+
+class HTTPLoggingMiddleware:
+    """Raw ASGI middleware to log HTTP request details including timing,
+    user context, and response information.
+
+    Unlike ``BaseHTTPMiddleware``, this does **not** buffer the response
+    body, so ``StreamingResponse`` and SSE endpoints work correctly.
+    """
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        request = Request(scope)
+        scope[REQUEST_SCOPE_KEY] = RequestScope()
+
+        elapsed = -time.perf_counter()
+
+        query_params: dict[str, list[str]] = defaultdict(list)
+        for key, value in request.query_params.multi_items():
+            query_params[key].append(value)
+
+        extras: dict[str, Any] = {
+            "method": request.method,
+            "uri": request.url.path,
+            "uri_mapping": self._get_route_path(request),
+            "query_params": query_params,
+            "hit_id": request.headers.get("x-client-hit-id") or str(uuid.uuid4()),
+            "app_id": request.headers.get("x-client-app-id", "unknown"),
+        }
+
+        logger.info("http.request.start", extra=extras)
+
+        # Track response status via a wrapper around send
+        status_holder: dict[str, int] = {"status": 0}
+
+        async def send_wrapper(message: Any) -> None:
+            if message["type"] == "http.response.start":
+                status_holder["status"] = message["status"]
+            await send(message)
+
+        exc_info = None
+        level = logging.INFO
+        try:
+            await self.app(scope, receive, send_wrapper)
+            status = status_holder["status"]
+            level = self._get_log_level(status)
+        except Exception as exc:
+            status = getattr(exc, "status_code", 500)
+            extras["error"] = exc.__cause__
+            exc_info = exc
+            level = logging.ERROR
+            raise
+        finally:
+            ds_scope = scope.get(REQUEST_SCOPE_KEY) or {}
+            extras.update(
+                hit_id=ds_scope.get("hit_id", "unknown"),
+                app_id=ds_scope.get("app_id", "unknown"),
+            )
+            if user_info := ds_scope.get("user_info"):
+                extras.update(
+                    user_id=user_info.sub,
+                    user_email=user_info.user_name,
+                )
+            elapsed += time.perf_counter()
+            extras["elapsed_millis"] = int(elapsed * 1000)
+            extras["status"] = status
+            logger.log(level, "http.request.complete", exc_info=exc_info, extra=extras)
+
+    @staticmethod
+    def _get_log_level(status: int) -> int:
+        http_status = HTTPStatus(status)
+        if http_status.is_informational or http_status.is_success or http_status.is_redirection:
+            return logging.INFO
+        if http_status.is_client_error:
+            return logging.WARNING
+        return logging.ERROR
+
+    @staticmethod
+    def _get_route_path(request: Request) -> str:
+        for route in request.app.routes:
+            match, _ = route.matches(request.scope)
+            if match == Match.FULL:
+                return str(route.path)
+        return request.url.path
+
+
+__all__ = ("REQUEST_SCOPE_KEY", "HTTPLoggingMiddleware", "RequestScope")

csrd_context-0.1.0/src/csrd/context/middleware/_request.py

@@ -0,0 +1,51 @@
+"""Request context middleware for setting up headers context.
+
+Implemented as a raw ASGI middleware (no ``BaseHTTPMiddleware``) so that
+``StreamingResponse`` and SSE endpoints are not buffered.
+"""
+
+from starlette.requests import Request
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from .._contextvars import (
+    configure_headers_context_provider,
+    reset_headers_context,
+    set_headers_context,
+)
+from .._fastapi_headers import headers_context
+
+
+def _setup_fastapi_headers_provider() -> None:
+    """Wire the FastAPI headers ContextVar as the headers provider."""
+    configure_headers_context_provider(
+        get_headers=headers_context.get,
+        set_headers=headers_context.set,
+        reset_headers=headers_context.reset,
+    )
+
+
+class RequestContextMiddleware:
+    """Raw ASGI middleware that captures request headers into context variables.
+
+    Unlike ``BaseHTTPMiddleware``, this does **not** buffer the response body,
+    so ``StreamingResponse`` and SSE endpoints work correctly.
+    """
+
+    def __init__(self, app: ASGIApp, **kwargs: object) -> None:
+        self.app = app
+        _setup_fastapi_headers_provider()
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        request = Request(scope)
+        token = set_headers_context(request.headers)
+        try:
+            await self.app(scope, receive, send)
+        finally:
+            reset_headers_context(token)
+
+
+__all__ = ("RequestContextMiddleware",)

csrd_context-0.1.0/src/csrd/context/platform.py

@@ -0,0 +1,21 @@
+"""Platform-level context variables for user info, hit-id, and app-id."""
+
+from contextvars import ContextVar
+from typing import Any
+
+__all__ = (
+    "APP_ID_KEY",
+    "HIT_ID_KEY",
+    "USER_INFO_KEY",
+    "app_id_context",
+    "hit_id_context",
+    "user_info_context",
+)
+
+USER_INFO_KEY = "user_info"
+HIT_ID_KEY = "hit_id"
+APP_ID_KEY = "app_id"
+
+user_info_context: ContextVar[Any | None] = ContextVar(USER_INFO_KEY, default=None)
+hit_id_context: ContextVar[str] = ContextVar(HIT_ID_KEY, default="unknown")
+app_id_context: ContextVar[str] = ContextVar(APP_ID_KEY, default="unknown")

csrd_context-0.1.0/tests/test_contextvars.py

@@ -0,0 +1,115 @@
+"""Tests for csrd.context contextvars system."""
+
+import pytest
+
+from csrd.context._contextvars import (
+    configure_headers_context_provider,
+    get_api_version,
+    get_app_id,
+    get_headers,
+    get_hit_id,
+    get_path_params,
+    get_query_params,
+    reset_api_version_context,
+    reset_global_configuration,
+    reset_headers_context,
+    reset_path_params,
+    reset_query_params,
+    set_api_version_context,
+    set_headers_context,
+    set_path_params,
+    set_query_params,
+)
+from csrd.context._models import PathValue
+
+
+class TestPathParamsContext:
+    def test_set_and_get(self):
+        token = set_path_params(PathValue({"id": "42"}))
+        try:
+            params = get_path_params()
+            assert params["id"] == "42"
+            assert params.id == "42"
+        finally:
+            reset_path_params(token)
+
+    def test_default_empty(self):
+        params = get_path_params()
+        assert len(params) == 0
+
+    def test_reset(self):
+        token = set_path_params(PathValue({"x": "y"}))
+        reset_path_params(token)
+        assert len(get_path_params()) == 0
+
+
+class TestQueryParamsContext:
+    def test_set_and_get(self):
+        token = set_query_params(PathValue({"page": "2"}))
+        try:
+            params = get_query_params()
+            assert params["page"] == "2"
+        finally:
+            reset_query_params(token)
+
+    def test_default_empty(self):
+        params = get_query_params()
+        assert len(params) == 0
+
+
+class TestApiVersionContext:
+    def test_set_and_get(self):
+        token = set_api_version_context("2025-06-20")
+        try:
+            assert get_api_version() == "2025-06-20"
+        finally:
+            reset_api_version_context(token)
+
+    def test_default_none(self):
+        assert get_api_version() is None
+
+
+class TestHeadersContext:
+    def setup_method(self):
+        reset_global_configuration()
+
+    def teardown_method(self):
+        reset_global_configuration()
+
+    def test_unconfigured_returns_empty_dict(self):
+        headers = get_headers()
+        assert headers == {}
+
+    def test_configure_and_use(self):
+        from contextvars import ContextVar
+
+        cv: ContextVar[dict] = ContextVar("test_headers")
+        cv.set({})
+
+        configure_headers_context_provider(
+            get_headers=cv.get,
+            set_headers=cv.set,
+            reset_headers=cv.reset,
+        )
+        token = set_headers_context({"x-client-app-id": "myapp", "x-client-hit-id": "hit123"})
+        try:
+            headers = get_headers()
+            assert headers["x-client-app-id"] == "myapp"
+            assert get_app_id() == "myapp"
+            assert get_hit_id() == "hit123"
+        finally:
+            reset_headers_context(token)
+
+    def test_set_headers_before_configure_raises(self):
+        with pytest.raises(RuntimeError, match="not configured"):
+            set_headers_context({"key": "val"})
+
+    def test_reset_headers_none_token_is_noop(self):
+        # Should not raise
+        reset_headers_context(None)
+
+    def test_get_app_id_unconfigured(self):
+        assert get_app_id() is None
+
+    def test_get_hit_id_unconfigured(self):
+        assert get_hit_id() is None

csrd_context-0.1.0/tests/test_middleware.py

@@ -0,0 +1,52 @@
+"""Tests for RequestContextMiddleware and HTTPLoggingMiddleware."""
+
+import pytest
+from fastapi import FastAPI
+from httpx import ASGITransport, AsyncClient
+
+from csrd.context import RequestContextMiddleware, get_headers
+from csrd.context._contextvars import reset_global_configuration
+
+
+@pytest.fixture
+def app():
+    app = FastAPI()
+
+    @app.get("/test")
+    async def test_endpoint():
+        headers = get_headers()
+        return {
+            "x-custom": headers.get("x-custom", "missing"),
+            "has_headers": len(dict(headers)) > 0,
+        }
+
+    app.add_middleware(RequestContextMiddleware)
+    return app
+
+
+@pytest.fixture
+def anyio_backend():
+    return "asyncio"
+
+
+class TestRequestContextMiddleware:
+    @pytest.mark.asyncio
+    async def test_headers_captured(self, app):
+        reset_global_configuration()
+        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
+            resp = await client.get("/test", headers={"x-custom": "hello"})
+            assert resp.status_code == 200
+            data = resp.json()
+            assert data["x-custom"] == "hello"
+            assert data["has_headers"] is True
+        reset_global_configuration()
+
+    @pytest.mark.asyncio
+    async def test_headers_isolated_between_requests(self, app):
+        reset_global_configuration()
+        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
+            resp1 = await client.get("/test", headers={"x-custom": "first"})
+            resp2 = await client.get("/test", headers={"x-custom": "second"})
+            assert resp1.json()["x-custom"] == "first"
+            assert resp2.json()["x-custom"] == "second"
+        reset_global_configuration()

csrd_context-0.1.0/tests/test_models.py

@@ -0,0 +1,45 @@
+"""Tests for PathValue dict wrapper."""
+
+import pytest
+
+from csrd.context._models import PathValue
+
+
+class TestPathValue:
+    def test_dict_access(self):
+        pv = PathValue({"user_id": "123", "org": "acme"})
+        assert pv["user_id"] == "123"
+
+    def test_dot_notation(self):
+        pv = PathValue({"user_id": "123"})
+        assert pv.user_id == "123"
+
+    def test_dot_notation_missing_raises_attribute_error(self):
+        pv = PathValue()
+        with pytest.raises(AttributeError, match="no key"):
+            _ = pv.missing_key
+
+    def test_set_via_dot_notation(self):
+        pv = PathValue()
+        pv.name = "Alice"
+        assert pv["name"] == "Alice"
+
+    def test_del_via_dot_notation(self):
+        pv = PathValue({"key": "val"})
+        del pv.key
+        assert "key" not in pv
+
+    def test_del_missing_raises(self):
+        pv = PathValue()
+        with pytest.raises(AttributeError):
+            del pv.nope
+
+    def test_dunder_attrs_use_regular_path(self):
+        pv = PathValue()
+        with pytest.raises(AttributeError):
+            _ = pv.__nonexistent__
+
+    def test_empty_defaults(self):
+        pv = PathValue()
+        assert len(pv) == 0
+        assert dict(pv) == {}

csrd_context-0.1.0/tests/test_platform.py

@@ -0,0 +1,30 @@
+"""Tests for platform-level context variables."""
+
+from csrd.context.platform import app_id_context, hit_id_context, user_info_context
+from csrd.models.claims import UserClaims
+
+
+class TestPlatformContextVars:
+    def test_user_info_default_none(self):
+        assert user_info_context.get() is None
+
+    def test_user_info_set_and_get(self):
+        claims = UserClaims(sub="user1", user_name="alice")
+        token = user_info_context.set(claims)
+        try:
+            assert user_info_context.get().sub == "user1"
+        finally:
+            user_info_context.reset(token)
+
+    def test_hit_id_default(self):
+        assert hit_id_context.get() == "unknown"
+
+    def test_app_id_default(self):
+        assert app_id_context.get() == "unknown"
+
+    def test_hit_id_set(self):
+        token = hit_id_context.set("req-abc-123")
+        try:
+            assert hit_id_context.get() == "req-abc-123"
+        finally:
+            hit_id_context.reset(token)