sie-config 0.8.0__tar.gz

sie_config-0.8.0/.gitignore

@@ -0,0 +1,273 @@
+# Byte-compiled / optimized / DLL files
+.codex/artifacts/worktree-task/
+
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+# JS/TS projects under tools/ legitimately use a `lib/` directory.
+!tools/*/lib/
+!tools/*/lib/**
+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/
+
+# Rust
+*.rs.bk
+
+# 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
+# Local service credential bundles must never be committed.
+*-secrets.env
+.env.cloud
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# 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
+
+# vcscode
+.vscode
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# SIE specific
+# Model weights cache
+.cache/
+*.safetensors
+*.bin
+
+# Secrets (never commit)
+*.pem
+*.key
+credentials.json
+*-key.json
+
+# Terraform
+# Local .terraform directories (cached providers/modules)
+**/.terraform/*
+.terraform.lock*
+# State files (contain sensitive data)
+*.tfstate
+*.tfstate.*
+# Crash log files
+crash.log
+crash.*.log
+# Override files (local developer overrides)
+override.tf
+override.tf.json
+*_override.tf
+*_override.tf.json
+# tfvars files may contain secrets
+*.tfvars
+*.tfvars.json
+
+# Node.js
+node_modules/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# VIM
+*.swp
+
+# kilocode
+.kilo/
+.kilocode/
+
+# Worktree metadata
+.base-branch
+
+# Temporary files
+tmp/
+.tmp/
+.local/
+
+b6_results.json
+# Personal mise overrides (per-developer toolchain tweaks, e.g. rustup
+# component naming differences across rustup versions).
+mise.local.toml

sie_config-0.8.0/Dockerfile

@@ -0,0 +1,82 @@
+# syntax=docker/dockerfile:1.6
+# SIE Config Service - Config control plane for SIE clusters
+# Lightweight image (~150MB) - no GPU dependencies
+#
+# Build:
+#   docker build -t sie-config:latest -f packages/sie_config/Dockerfile .
+#
+# Run:
+#   docker run -p 8080:8080 sie-config:latest
+
+# =============================================================================
+# Dependency builder: install service dependencies
+# =============================================================================
+FROM python:3.12-slim AS builder
+
+WORKDIR /app
+
+# Copy sie-sdk first (dependency of sie-config)
+COPY packages/sie_sdk /tmp/sie_sdk
+
+# Copy sie-config files
+COPY packages/sie_config/pyproject.toml ./
+COPY packages/sie_config/src src/
+
+# Create venv and install everything with pip
+RUN --mount=type=cache,target=/root/.cache/pip \
+    python -m venv .venv \
+    && .venv/bin/pip install --upgrade pip \
+    && .venv/bin/pip install \
+        -e /tmp/sie_sdk \
+        -e "."
+
+# Clean up to reduce image size
+RUN find .venv -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true \
+    && find .venv -type f -name "*.pyc" -delete 2>/dev/null || true \
+    && find .venv -type d -name "tests" -exec rm -rf {} + 2>/dev/null || true \
+    && find .venv -type d -name "test" -exec rm -rf {} + 2>/dev/null || true
+
+# =============================================================================
+# Runtime image: minimal config service
+# =============================================================================
+FROM python:3.12-slim AS runtime
+
+# Create non-root user
+RUN groupadd --gid 1000 sie \
+    && useradd --uid 1000 --gid 1000 --create-home --shell /bin/bash sie
+
+WORKDIR /app
+
+# Copy virtual environment from builder
+COPY --from=builder --chown=sie:sie /app/.venv /app/.venv
+
+# Copy source code (pip -e creates editable install with .pth pointing to src)
+COPY --from=builder --chown=sie:sie /app/src /app/src
+
+# Copy sie-sdk source (installed as editable in /tmp)
+COPY --from=builder --chown=sie:sie /tmp/sie_sdk/src /tmp/sie_sdk/src
+
+# Copy model and bundle configs (required for ModelRegistry)
+# Config service needs these to know which models exist and their bundle mappings
+COPY --chown=sie:sie packages/sie_server/bundles /app/bundles
+COPY --chown=sie:sie packages/sie_server/models /app/models
+
+# Set up PATH and model config paths
+ENV PATH="/app/.venv/bin:$PATH" \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    SIE_BUNDLES_DIR=/app/bundles \
+    SIE_MODELS_DIR=/app/models
+
+USER sie
+
+# Default port
+EXPOSE 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/healthz')" || exit 1
+
+# Default command
+ENTRYPOINT ["sie-config", "serve"]
+CMD ["--port", "8080"]

sie_config-0.8.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.5
+Name: sie-config
+Version: 0.8.0
+Summary: SIE Config Service - Config control plane for SIE clusters
+License: Apache-2.0
+Requires-Python: <3.13,>=3.12
+Requires-Dist: fastapi<1,>=0.115
+Requires-Dist: nats-py<3,>=2.9
+Requires-Dist: opentelemetry-api<2,>=1.28
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc<2,>=1.28
+Requires-Dist: opentelemetry-exporter-otlp-proto-http<2,>=1.28
+Requires-Dist: opentelemetry-sdk<2,>=1.28
+Requires-Dist: orjson<4,>=3.10
+Requires-Dist: pyyaml<7,>=6
+Requires-Dist: requests<3,>=2.32
+Requires-Dist: rich<14,>=13
+Requires-Dist: sie-sdk[storage]>=0.1
+Requires-Dist: typer<1,>=0.14
+Requires-Dist: uvicorn[standard]<1,>=0.32
+Requires-Dist: uvloop>=0.22
+Provides-Extra: gcs
+Requires-Dist: google-cloud-storage<3,>=2.18; extra == 'gcs'

sie_config-0.8.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "sie-config"
+version = "0.8.0"
+description = "SIE Config Service - Config control plane for SIE clusters"
+requires-python = ">=3.12,<3.13"
+license = { text = "Apache-2.0" }
+dependencies = [
+    "fastapi>=0.115,<1",
+    "uvicorn[standard]>=0.32,<1",
+    "uvloop>=0.22",
+    "nats-py>=2.9,<3",
+    "opentelemetry-api>=1.28,<2",
+    "opentelemetry-exporter-otlp-proto-grpc>=1.28,<2",
+    "opentelemetry-exporter-otlp-proto-http>=1.28,<2",
+    "opentelemetry-sdk>=1.28,<2",
+    "orjson>=3.10,<4",
+    "pyyaml>=6,<7",
+    "requests>=2.32,<3",
+    "sie-sdk[storage]>=0.1",
+    "typer>=0.14,<1",
+    "rich>=13,<14",
+]
+
+[project.optional-dependencies]
+gcs = ["google-cloud-storage>=2.18,<3"]
+
+[project.scripts]
+sie-config = "sie_config.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sie_config"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+    "pytest-asyncio>=1.0",
+]

sie_config-0.8.0/src/sie_config/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

sie_config-0.8.0/src/sie_config/app_factory.py

@@ -0,0 +1,249 @@
+import logging
+import os
+import time
+from collections.abc import AsyncGenerator, Callable
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, Request
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.responses import Response
+
+from sie_config import metrics as sie_metrics
+from sie_config.config_api import router as config_router
+from sie_config.config_store import ConfigStore
+from sie_config.health import router as health_router
+from sie_config.managed_metrics import setup_managed_metrics
+from sie_config.model_registry import ModelRegistry
+from sie_config.nats_publisher import NatsPublisher
+
+logger = logging.getLogger(__name__)
+
+# Default paths for bundle and model configs.
+# In Docker, SIE_BUNDLES_DIR and SIE_MODELS_DIR are always set (see Dockerfile).
+# In development, fall back to the sibling sie_server package in the source tree.
+_DEFAULT_BUNDLES_DIR = Path(__file__).parent.parent.parent.parent / "sie_server" / "bundles"
+_DEFAULT_MODELS_DIR = Path(__file__).parent.parent.parent.parent / "sie_server" / "models"
+_BOUNDED_HTTP_METHODS = frozenset({"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"})
+
+
+class _TelemetryHTTPMiddleware(BaseHTTPMiddleware):
+    # Record one backend-neutral config HTTP observation for every request.
+    #
+    # The `path` label is the FastAPI route template (e.g.
+    # `/v1/configs/models/{model_id}`) rather than the raw URL so
+    # per-model reads do not explode the label cardinality. We resolve
+    # the route after the downstream handler runs -- Starlette only
+    # populates `request.scope["route"]` once routing has matched. Unknown
+    # URLs collapse to the contract's bounded `other` label; the Modal URL is
+    # externally reachable, so retaining arbitrary request paths would let a
+    # caller create unbounded time series.
+    #
+    # The exception path matters as much as the success one. If
+    # `call_next(...)` raises, Starlette converts the exception into a
+    # 500 *outside* this middleware, so a naive `response = await
+    # call_next(request)` followed by `.labels(...)` would miss exactly
+    # the failures operators care about most. We wrap the entire
+    # critical section in `try / except / finally` so that:
+    #   - a raised exception still bumps `status="500"` in the counter
+    #     and observes latency (the timing is meaningful -- a 50 ms
+    #     crash is very different from a 30 s one),
+    #   - the original exception is re-raised so Starlette's default
+    #     500 handler runs and the client sees the same response it
+    #     would without this middleware.
+
+    async def dispatch(
+        self,
+        request: Request,
+        call_next: RequestResponseEndpoint,
+    ) -> Response:
+        # `status_code` is seeded at 500 so an exception raised
+        # inside `call_next` (before we can read `response.status_code`)
+        # still attributes the failure correctly in the `finally` block.
+        # FastAPI/Starlette's outer exception handler turns the raised
+        # exception into a 500 for the client, so counting it as a 500
+        # matches what the caller actually sees.
+        start = time.monotonic()
+        status_code = 500
+        try:
+            response = await call_next(request)
+            status_code = response.status_code
+            return response
+        finally:
+            elapsed = time.monotonic() - start
+            route = request.scope.get("route")
+            path_label = getattr(route, "path", None) or "other"
+            method_label = request.method if request.method in _BOUNDED_HTTP_METHODS else "other"
+
+            sie_metrics.record_http_request(
+                method=method_label,
+                path=path_label,
+                status=status_code,
+                duration_s=elapsed,
+            )
+            if path_label == "/v1/configs/export":
+                sie_metrics.record_snapshot_publish(success=200 <= status_code < 300)
+
+
+class AppFactory:
+    """Factory for creating the SIE Config Service FastAPI application."""
+
+    @classmethod
+    def create_app(cls) -> FastAPI:
+        """Create and configure the FastAPI application.
+
+        Returns:
+            Configured FastAPI application instance.
+        """
+        setup_managed_metrics()
+        app = FastAPI(
+            title="SIE Config Service",
+            description="Config control plane for SIE clusters",
+            version="0.1.0",
+            lifespan=cls._create_lifespan(),
+        )
+
+        # Do not install request instrumentation at all when telemetry is
+        # disabled. A no-op OTel meter still leaves clock reads, route
+        # resolution and attribute preparation on every request; omitting the
+        # middleware makes the public disabled path a true pass-through.
+        #
+        # When enabled, telemetry must wrap the app BEFORE the routers mount
+        # so it observes every request (including errors raised before a route
+        # matches, e.g. body-size rejections). Starlette applies middleware in
+        # outer-to-inner order, so adding it first makes it the outermost layer.
+        if sie_metrics.telemetry_enabled():
+            app.add_middleware(_TelemetryHTTPMiddleware)
+
+        app.include_router(health_router)
+        app.include_router(config_router)
+
+        return app
+
+    @classmethod
+    def _create_lifespan(cls) -> Callable[[FastAPI], Any]:
+        """Create the lifespan context manager for the application."""
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+            """Application lifespan manager."""
+            logger.info("Starting SIE Config Service")
+
+            async with (
+                cls._model_registry(app),
+                cls._config_store(app),
+                cls._nats_publisher(app),
+            ):
+                yield
+
+            logger.info("Stopped SIE Config Service")
+
+        return lifespan
+
+    @classmethod
+    @asynccontextmanager
+    async def _model_registry(cls, app: FastAPI) -> AsyncGenerator[None, None]:
+        """Initialize ModelRegistry for model->bundle mapping."""
+        bundles_dir = Path(os.environ.get("SIE_BUNDLES_DIR", str(_DEFAULT_BUNDLES_DIR)))
+        models_dir = Path(os.environ.get("SIE_MODELS_DIR", str(_DEFAULT_MODELS_DIR)))
+
+        try:
+            model_registry = ModelRegistry(bundles_dir, models_dir)
+            app.state.model_registry = model_registry
+            unrouteable = model_registry.unrouteable_models
+            logger.info(
+                "ModelRegistry initialized: %d bundles, %d models (%d unrouteable)",
+                len(model_registry.list_bundles()),
+                len(model_registry.list_models()),
+                len(unrouteable),
+            )
+            # Seed the models gauge. At this point every model came
+            # from disk; the `api`-sourced tally catches up once
+            # ConfigStore restore runs in `_config_store`.
+            sie_metrics.update_models_gauge(
+                api_count=0,
+                filesystem_count=len(model_registry.list_models()),
+            )
+        except Exception:
+            logger.exception("Failed to initialize ModelRegistry, continuing without it")
+            app.state.model_registry = None
+
+        yield
+
+    @classmethod
+    @asynccontextmanager
+    async def _config_store(cls, app: FastAPI) -> AsyncGenerator[None, None]:
+        """Initialize config store for persisting API-added model configs."""
+        config_dir = os.environ.get("SIE_CONFIG_STORE_DIR")
+        if config_dir:
+            store = ConfigStore(config_dir)
+            app.state.config_store = store
+            initial_epoch = store.read_epoch()
+            logger.info("Config store initialized at %s (epoch=%d)", config_dir, initial_epoch)
+            # Mirror the persisted epoch into telemetry so the
+            # `sie.config.epoch` gauge reflects reality immediately on
+            # startup. Without this, dashboards would read 0 until the
+            # first successful `POST /v1/configs/models` call bumped
+            # the counter — which, crucially, never happens in a
+            # read-only control plane.
+            sie_metrics.set_epoch(initial_epoch)
+
+            if os.environ.get("SIE_CONFIG_RESTORE", "").lower() == "true":
+                model_registry: ModelRegistry | None = app.state.model_registry
+                if model_registry is None:
+                    logger.warning("Cannot restore configs -- ModelRegistry not initialized")
+                else:
+                    stored_models = store.load_all_models()
+                    for model_id, model_config in stored_models.items():
+                        try:
+                            model_registry.add_model_config(model_config)
+                            logger.info("Restored model from config store: %s", model_id)
+                        except Exception:
+                            logger.exception("Failed to restore model: %s", model_id)
+                    if stored_models:
+                        logger.info("Restored %d models from config store", len(stored_models))
+                    # Recompute the split now that API-added models
+                    # have been folded back into the registry.
+                    api_count = len(store.list_models())
+                    total = len(model_registry.list_models())
+                    sie_metrics.update_models_gauge(
+                        api_count=api_count,
+                        filesystem_count=max(total - api_count, 0),
+                    )
+        else:
+            app.state.config_store = None
+            # Epoch zero is authoritative in no-store deployments. Seed the
+            # synchronous gauge explicitly so dashboards distinguish that
+            # state from a producer that never emitted telemetry.
+            sie_metrics.set_epoch(0)
+
+        yield
+
+    @classmethod
+    @asynccontextmanager
+    async def _nats_publisher(cls, app: FastAPI) -> AsyncGenerator[None, None]:
+        """Initialize NATS publisher for config distribution."""
+        nats_url = os.environ.get("SIE_NATS_URL")
+        nats_publisher: NatsPublisher | None = None
+
+        # The asynchronous dial may take the full startup retry budget, and a
+        # deployment without NATS never dials at all. In both cases false is an
+        # authoritative current value rather than an absent series.
+        sie_metrics.set_nats_connected(False)
+
+        if nats_url:
+            nats_publisher = NatsPublisher(nats_url=nats_url)
+            app.state.nats_publisher = nats_publisher
+            # Do not await NATS here: it can outlast startup probe budgets while the
+            # NATS pod schedules; /healthz must bind as soon as model registry + store init finish.
+            nats_publisher.kickoff_connect()
+        else:
+            app.state.nats_publisher = None
+            logger.info("NATS not configured (SIE_NATS_URL not set) -- config distribution disabled")
+
+        try:
+            yield
+        finally:
+            if nats_publisher:
+                await nats_publisher.disconnect()