microcosm-emitter 0.2.0__py3-none-any.whl

microcosm_emitter/__init__.py

@@ -0,0 +1 @@
+"""Local emitter host and required telemetry library, without import side effects."""

microcosm_emitter/core/__init__.py

@@ -0,0 +1 @@
+"""Shared provider services; importing this package has no runtime side effects."""

microcosm_emitter/core/alembic/env.py

@@ -0,0 +1,28 @@
+"""Alembic environment for the local telemetry spool."""
+
+from alembic import context
+from sqlalchemy.engine import Connection
+
+from microcosm_emitter.core.models import SpoolModel
+
+_MISSING_CONNECTION_ERROR = (
+    "telemetry spool migrations require a programmatically supplied connection"
+)
+
+
+def run_migrations() -> None:
+    """Run migrations on the connection supplied by the emitter service."""
+
+    connection = context.config.attributes.get("connection")
+    if not isinstance(connection, Connection):
+        raise RuntimeError(_MISSING_CONNECTION_ERROR)
+    context.configure(
+        connection=connection,
+        target_metadata=SpoolModel.metadata,
+        render_as_batch=True,
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+run_migrations()

microcosm_emitter/core/alembic/script.py.mako

@@ -0,0 +1,31 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+${imports if imports else ""}
+
+revision: str = ${repr(up_revision)}
+down_revision: str | None = ${repr(down_revision)}
+branch_labels: str | Sequence[str] | None = ${repr(branch_labels)}
+depends_on: str | Sequence[str] | None = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Apply this schema revision."""
+
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Reverse this schema revision."""
+
+    ${downgrades if downgrades else "pass"}

microcosm_emitter/core/alembic/versions/v20261007_01_initial_spool.py

@@ -0,0 +1,85 @@
+"""Create the telemetry spool schema.
+
+Revision ID: 20261007_01
+Revises:
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "20261007_01"
+down_revision: str | None = None
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+_RUNS_TABLE = "telemetry_runs"
+_EVENTS_TABLE = "telemetry_events"
+_EVENTS_INDEX = "telemetry_events_run_sequence"
+_PENDING_UPLOAD_STATE = "pending"
+
+
+def _create_runs_table() -> None:
+    op.create_table(
+        _RUNS_TABLE,
+        sa.Column("run_id", sa.Text(), nullable=False),
+        sa.Column("producer_id", sa.Text(), nullable=False),
+        sa.Column("registration_json", sa.Text(), nullable=False),
+        sa.Column(
+            "next_sequence",
+            sa.Integer(),
+            nullable=False,
+            server_default="1",
+        ),
+        sa.Column(
+            "upload_state",
+            sa.Text(),
+            nullable=False,
+            server_default=_PENDING_UPLOAD_STATE,
+        ),
+        sa.Column("local_only_reason", sa.Text(), nullable=True),
+        sa.Column("updated_at", sa.Text(), nullable=False),
+        sa.PrimaryKeyConstraint("run_id", "producer_id"),
+    )
+
+
+def _create_events_table() -> None:
+    op.create_table(
+        _EVENTS_TABLE,
+        sa.Column("event_id", sa.Text(), nullable=False),
+        sa.Column("run_id", sa.Text(), nullable=False),
+        sa.Column("producer_id", sa.Text(), nullable=False),
+        sa.Column("sequence", sa.Integer(), nullable=False),
+        sa.Column("payload_json", sa.Text(), nullable=False),
+        sa.Column("created_at", sa.Text(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["run_id", "producer_id"],
+            [f"{_RUNS_TABLE}.run_id", f"{_RUNS_TABLE}.producer_id"],
+            name="fk_telemetry_events_run",
+        ),
+        sa.PrimaryKeyConstraint("event_id"),
+        sa.UniqueConstraint(
+            "run_id",
+            "producer_id",
+            "sequence",
+            name="uq_telemetry_events_run_producer_sequence",
+        ),
+    )
+
+
+def upgrade() -> None:
+    """Create a new database; existing schemas must already be versioned."""
+    _create_runs_table()
+    _create_events_table()
+    op.create_index(_EVENTS_INDEX, _EVENTS_TABLE, ["run_id", "producer_id", "sequence"])
+
+
+def downgrade() -> None:
+    """Remove the local spool schema."""
+
+    op.drop_index(_EVENTS_INDEX, table_name=_EVENTS_TABLE)
+    op.drop_table(_EVENTS_TABLE)
+    op.drop_table(_RUNS_TABLE)

microcosm_emitter/core/alembic/versions/v20261008_02_graph_publication.py

@@ -0,0 +1,27 @@
+"""Add durable graph publication jobs without changing event retention."""
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "20261008_02"
+down_revision = "20261007_01"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "graph_publication_jobs",
+        sa.Column("publication_id", sa.Text(), primary_key=True),
+        sa.Column("inventory", sa.Text(), nullable=False),
+        sa.Column("directory", sa.Text(), nullable=False),
+        sa.Column("status", sa.Text(), nullable=False),
+        sa.Column("attempts", sa.Integer(), nullable=False),
+        sa.Column("next_attempt_at", sa.Float(), nullable=False),
+        sa.Column("lease_until", sa.Float(), nullable=False),
+        sa.Column("receipt", sa.Text(), nullable=False),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("graph_publication_jobs")

microcosm_emitter/core/auth.py

@@ -0,0 +1,169 @@
+"""HF-to-collector session shared by telemetry and graph publication."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from collections.abc import Mapping
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import urlsplit
+
+from huggingface_hub import get_token
+
+from microcosm_emitter.core.constants import (
+    COLLECTOR_RESPONSE_TOO_LARGE_ERROR,
+    COLLECTOR_URL_HTTPS_ERROR,
+    COLLECTOR_URL_ORIGIN_ERROR,
+    DEFAULT_TOKEN_LIFETIME_SECONDS,
+    DEVELOPMENT_COLLECTOR_LOOPBACK_ERROR,
+    HTTP_TIMEOUT_SECONDS,
+    HTTP_USER_AGENT,
+    LOOPBACK_HOSTS,
+    MAX_HTTP_RESPONSE_BYTES,
+    MINIMUM_TOKEN_LIFETIME_SECONDS,
+    TOKEN_EXCHANGE_PATH,
+    TOKEN_REFRESH_MARGIN_SECONDS,
+)
+
+
+class _NoRedirectHandler(urllib.request.HTTPRedirectHandler):
+    """Keep bearer credentials on the explicitly configured origin."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def _collector_origin(value: str, *, allow_loopback_http: bool = False) -> str:
+    parsed = urlsplit(value)
+    loopback = parsed.hostname in LOOPBACK_HOSTS
+    valid_scheme = parsed.scheme == "https" or (
+        allow_loopback_http and loopback and parsed.scheme == "http"
+    )
+    if not parsed.hostname or not valid_scheme:
+        raise ValueError(COLLECTOR_URL_HTTPS_ERROR)
+    if (
+        parsed.username
+        or parsed.password
+        or parsed.query
+        or parsed.fragment
+        or parsed.path not in {"", "/"}
+    ):
+        raise ValueError(COLLECTOR_URL_ORIGIN_ERROR)
+    return value.rstrip("/")
+
+
+def _development_collector_url(value: str) -> str:
+    parsed = urlsplit(value)
+    if parsed.hostname not in LOOPBACK_HOSTS:
+        raise ValueError(DEVELOPMENT_COLLECTOR_LOOPBACK_ERROR)
+    return _collector_origin(value, allow_loopback_http=True)
+
+
+def _decode_response(body: bytes) -> dict[str, Any]:
+    try:
+        response = json.loads(body) if body else {}
+    except (json.JSONDecodeError, UnicodeDecodeError):
+        return {}
+    return response if isinstance(response, dict) else {}
+
+
+def _http_post(
+    url: str,
+    payload: Mapping[str, Any],
+    bearer_token: str,
+    *,
+    timeout: float = HTTP_TIMEOUT_SECONDS,
+) -> tuple[int, dict[str, Any]]:
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(payload, separators=(",", ":")).encode(),
+        headers={
+            "Authorization": f"Bearer {bearer_token}",
+            "Content-Type": "application/json",
+            "User-Agent": HTTP_USER_AGENT,
+        },
+        method="POST",
+    )
+    try:
+        opener = urllib.request.build_opener(_NoRedirectHandler)
+        with opener.open(request, timeout=timeout) as response:
+            body = response.read(MAX_HTTP_RESPONSE_BYTES + 1)
+            if len(body) > MAX_HTTP_RESPONSE_BYTES:
+                raise OSError(COLLECTOR_RESPONSE_TOO_LARGE_ERROR)
+            return response.status, _decode_response(body)
+    except urllib.error.HTTPError as error:
+        body = error.read(MAX_HTTP_RESPONSE_BYTES + 1)
+        if len(body) > MAX_HTTP_RESPONSE_BYTES:
+            return error.code, {}
+        return error.code, _decode_response(body)
+
+
+def _huggingface_token() -> str | None:
+    return (
+        os.environ.get("HF_TOKEN", "").strip()
+        or os.environ.get("HUGGINGFACE_TOKEN", "").strip()
+        or get_token()
+    )
+
+
+class CollectorSession:
+    """One thread-safe short-lived credential shared by independent publishers."""
+
+    def __init__(self, origin: str, *, post=None, credential=None):
+        import threading
+
+        self.origin = origin
+        self._post = post or _http_post
+        self._credential = credential or _huggingface_token
+        self._session_token: tuple[str, float] | None = None
+        self._lock = threading.Lock()
+
+    def invalidate(self) -> None:
+        with self._lock:
+            self._session_token = None
+
+    def credential(self) -> tuple[str, str | None]:
+        with self._lock:
+            if (
+                self._session_token is not None
+                and self._session_token[1]
+                > time.monotonic() + TOKEN_REFRESH_MARGIN_SECONDS
+            ):
+                return "ok", self._session_token[0]
+            hf_token = self._credential()
+            if not hf_token:
+                return "missing", None
+            try:
+                status, response = self._post(
+                    self.origin + TOKEN_EXCHANGE_PATH, {}, hf_token
+                )
+            except (OSError, TimeoutError):
+                return "unavailable", None
+            if status == HTTPStatus.OK and isinstance(
+                response.get("access_token"), str
+            ):
+                try:
+                    expires_in = max(
+                        MINIMUM_TOKEN_LIFETIME_SECONDS,
+                        int(response.get("expires_in", DEFAULT_TOKEN_LIFETIME_SECONDS)),
+                    )
+                except (ValueError, TypeError):
+                    return "unavailable", None
+                token = response["access_token"]
+                self._session_token = (token, time.monotonic() + expires_in)
+                return "ok", token
+            if status in {HTTPStatus.UNAUTHORIZED, HTTPStatus.FORBIDDEN}:
+                return "rejected", None
+            return "unavailable", None
+
+
+def shared_session(services: dict, origin: str) -> CollectorSession:
+    """Share a session among explicit modules without adding auth to the host."""
+    session = services.setdefault("collector_session", CollectorSession(origin))
+    if not isinstance(session, CollectorSession) or session.origin != origin:
+        raise ValueError("Provider modules must use the same collector origin.")
+    return session

microcosm_emitter/core/constants.py

@@ -0,0 +1,69 @@
+"""Configuration and protocol values for the telemetry emitter service."""
+
+from __future__ import annotations
+
+from typing import Final
+
+RETENTION_DAYS: Final = 7
+MAX_QUEUED_BYTES: Final = 100 * 1024 * 1024
+BATCH_SIZE: Final = 100
+PRODUCTION_COLLECTOR_URL: Final = (
+    "https://microcosm-telemetry-389282473430.us-central1.run.app"
+)
+
+LOOPBACK_HOSTS: Final = frozenset({"localhost", "127.0.0.1", "::1"})
+TOKEN_EXCHANGE_PATH: Final = "/v1/auth/huggingface/exchange"
+RUN_REGISTRATION_PATH: Final = "/v1/runs"
+RUN_EVENTS_PATH_TEMPLATE: Final = "/v1/runs/{run_id}/events"
+HTTP_USER_AGENT: Final = "microcosm-telemetry-emitter/1"
+MAX_HTTP_RESPONSE_BYTES: Final = 1_048_576
+HTTP_TIMEOUT_SECONDS: Final = 5.0
+
+UPLOAD_STATE_PENDING: Final = "pending"
+UPLOAD_STATE_LOCAL_ONLY: Final = "local_only"
+LOCAL_ONLY_MISSING_CREDENTIAL: Final = "missing_huggingface_credential"
+LOCAL_ONLY_REJECTED_CREDENTIAL: Final = "huggingface_credential_rejected"
+LOCAL_ONLY_REJECTED_REGISTRATION: Final = "run_registration_rejected"
+LOCAL_ONLY_REJECTED_COLLECTOR_AUTHORIZATION: Final = "collector_authorization_rejected"
+LOCAL_ONLY_PRE_ELIGIBILITY: Final = "created_before_upload_eligibility"
+
+NO_CREDENTIAL_MESSAGE: Final = (
+    "Microcosm telemetry is local-only: no ambient Hugging Face credential was "
+    "found. The dataset build will continue."
+)
+REJECTED_CREDENTIAL_MESSAGE: Final = (
+    "Microcosm telemetry is local-only for this run: the ambient Hugging Face "
+    "credential was not accepted as a PolicyEngine organization member. The "
+    "dataset build will continue."
+)
+COLLECTOR_URL_HTTPS_ERROR: Final = "collector URL must be an HTTPS origin"
+COLLECTOR_URL_ORIGIN_ERROR: Final = (
+    "collector URL must be an origin without credentials or path data"
+)
+DEVELOPMENT_COLLECTOR_LOOPBACK_ERROR: Final = (
+    "development collector URL must use a loopback address"
+)
+COLLECTOR_RESPONSE_TOO_LARGE_ERROR: Final = "collector response exceeds 1 MiB"
+
+DEFAULT_TOKEN_LIFETIME_SECONDS: Final = 3_600
+MINIMUM_TOKEN_LIFETIME_SECONDS: Final = 60
+TOKEN_REFRESH_MARGIN_SECONDS: Final = 30
+INITIAL_RETRY_SECONDS: Final = 1.0
+MAX_RETRY_SECONDS: Final = 60.0
+
+DATABASE_TIMEOUT_SECONDS: Final = 5
+PRUNE_INTERVAL_SECONDS: Final = 60.0
+
+DEFAULT_HEARTBEAT_SECONDS: Final = 60.0
+DEFAULT_DRAIN_SECONDS: Final = 15.0
+MINIMUM_HEARTBEAT_SECONDS: Final = 1.0
+SOCKET_LISTEN_BACKLOG: Final = 16
+SOCKET_ACCEPT_TIMEOUT_SECONDS: Final = 0.5
+SOCKET_CONNECTION_TIMEOUT_SECONDS: Final = 0.25
+WORKER_INTERVAL_SECONDS: Final = 1.0
+DRAIN_RETRY_SECONDS: Final = 0.5
+
+EVENT_OBJECT_ERROR: Final = "event must be an object"
+UNSUPPORTED_ACTION_ERROR: Final = "unsupported local telemetry action"
+LOCAL_MESSAGE_TOO_LARGE_ERROR: Final = "local telemetry message exceeds 1 MiB"
+FAILURE_CLASS_UNEXPECTED_PROCESS_EXIT: Final = "unexpected_process_exit"

microcosm_emitter/core/database.py

@@ -0,0 +1,34 @@
+"""SQLAlchemy engine and session construction for the telemetry spool."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from sqlalchemy import URL, create_engine
+from sqlalchemy.engine import Engine
+from sqlalchemy.orm import Session, sessionmaker
+
+from microcosm_emitter.core.constants import (
+    DATABASE_TIMEOUT_SECONDS,
+)
+
+
+def sqlite_database_url(path: Path | str) -> URL:
+    """Return a SQLAlchemy URL for a local SQLite spool path."""
+
+    return URL.create("sqlite+pysqlite", database=str(Path(path)))
+
+
+def create_spool_engine(path: Path | str) -> Engine:
+    """Create the SQLAlchemy engine used by one emitter service process."""
+
+    return create_engine(
+        sqlite_database_url(path),
+        connect_args={"timeout": DATABASE_TIMEOUT_SECONDS},
+    )
+
+
+def create_spool_session_factory(engine: Engine) -> sessionmaker[Session]:
+    """Create short-lived ORM sessions bound to the spool engine."""
+
+    return sessionmaker(engine, expire_on_commit=False)

microcosm_emitter/core/migrations.py

@@ -0,0 +1,78 @@
+"""Programmatic Alembic migration entry points for the telemetry spool."""
+
+from __future__ import annotations
+
+import fcntl
+from collections.abc import Iterator
+from contextlib import contextmanager
+from importlib.resources import as_file, files
+from pathlib import Path
+
+from alembic import command
+from alembic.config import Config
+from alembic.migration import MigrationContext
+from alembic.script import ScriptDirectory
+from sqlalchemy import inspect
+from sqlalchemy.engine import Connection, Engine
+
+from microcosm_emitter.core.database import create_spool_engine
+
+_MIGRATION_TARGET = "head"
+
+
+@contextmanager
+def alembic_config(
+    *,
+    connection: Connection | None = None,
+) -> Iterator[Config]:
+    """Yield Alembic configuration with migrations on the filesystem."""
+
+    migration_resources = files(__package__).joinpath("alembic")
+    with as_file(migration_resources) as migration_directory:
+        config = Config()
+        config.set_main_option("script_location", str(migration_directory))
+        if connection is not None:
+            config.attributes["connection"] = connection
+        yield config
+
+
+def upgrade_spool_database(engine: Engine) -> None:
+    """Apply every committed spool migration to an engine."""
+
+    # All build processes share this database. Serialize migration checks and
+    # upgrades; SQLite transaction locks alone do not serialize schema inspection.
+    path = Path(engine.url.database)
+    with path.with_suffix(".migration.lock").open("a") as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        with engine.begin() as connection:
+            names = set(inspect(connection).get_table_names())
+            revision = MigrationContext.configure(connection).get_current_revision()
+            if names and revision is None:
+                raise RuntimeError(
+                    "Refusing an unversioned telemetry database; no changes made."
+                )
+            with alembic_config(connection=connection) as config:
+                history = ScriptDirectory.from_config(config)
+                if revision is not None:
+                    history.get_revision(
+                        revision
+                    )  # Reject unknown revisions before writes.
+                command.upgrade(config, _MIGRATION_TARGET)
+
+
+def current_database_revision(path: Path | str) -> str | None:
+    """Return the Alembic revision recorded by one spool database."""
+
+    engine = create_spool_engine(path)
+    try:
+        with engine.connect() as connection:
+            return MigrationContext.configure(connection).get_current_revision()
+    finally:
+        engine.dispose()
+
+
+def migration_head_revision() -> str | None:
+    """Return the single current head from the packaged migration history."""
+
+    with alembic_config() as config:
+        return ScriptDirectory.from_config(config).get_current_head()

microcosm_emitter/core/models.py

@@ -0,0 +1,145 @@
+"""SQLAlchemy ORM models for the local telemetry spool."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from sqlalchemy import (
+    Float,
+    ForeignKeyConstraint,
+    Index,
+    Integer,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+from sqlalchemy.types import TypeDecorator
+
+from microcosm_emitter.core.constants import (
+    UPLOAD_STATE_PENDING,
+)
+
+
+class JsonObjectText(TypeDecorator[dict[str, Any]]):
+    """Store JSON objects in the spool's existing text-column format."""
+
+    impl = Text
+    cache_ok = True
+
+    def process_bind_param(
+        self,
+        value: dict[str, Any] | None,
+        dialect,
+    ) -> str | None:
+        if value is None:
+            return None
+        return _serialize_json_object(value)
+
+    def process_result_value(
+        self,
+        value: str | None,
+        dialect,
+    ) -> dict[str, Any] | None:
+        if value is None:
+            return None
+        decoded = json.loads(value)
+        if not isinstance(decoded, dict):
+            raise ValueError("telemetry spool JSON must contain an object")
+        return decoded
+
+
+def serialized_json_length(value: dict[str, Any]) -> int:
+    """Return the stored character count for one mapped JSON object."""
+
+    return len(_serialize_json_object(value))
+
+
+def _serialize_json_object(value: dict[str, Any]) -> str:
+    return json.dumps(
+        value,
+        separators=(",", ":"),
+        sort_keys=True,
+        allow_nan=False,
+    )
+
+
+class SpoolModel(DeclarativeBase):
+    """Declarative base for the local telemetry spool."""
+
+
+class TelemetryRunRecord(SpoolModel):
+    """One telemetry producer registered for one build run."""
+
+    __tablename__ = "telemetry_runs"
+
+    run_id: Mapped[str] = mapped_column(Text, primary_key=True)
+    producer_id: Mapped[str] = mapped_column(Text, primary_key=True)
+    registration: Mapped[dict[str, Any]] = mapped_column(
+        "registration_json",
+        JsonObjectText,
+        nullable=False,
+    )
+    next_sequence: Mapped[int] = mapped_column(Integer, nullable=False, default=1)
+    upload_state: Mapped[str] = mapped_column(
+        Text,
+        nullable=False,
+        default=UPLOAD_STATE_PENDING,
+    )
+    local_only_reason: Mapped[str | None] = mapped_column(Text)
+    updated_at: Mapped[str] = mapped_column(Text, nullable=False)
+    events: Mapped[list[TelemetryEventRecord]] = relationship(
+        back_populates="run",
+        cascade="all, delete-orphan",
+    )
+
+
+class TelemetryEventRecord(SpoolModel):
+    """One ordered telemetry event awaiting collector acknowledgement."""
+
+    __tablename__ = "telemetry_events"
+    __table_args__ = (
+        UniqueConstraint(
+            "run_id",
+            "producer_id",
+            "sequence",
+            name="uq_telemetry_events_run_producer_sequence",
+        ),
+        ForeignKeyConstraint(
+            ["run_id", "producer_id"],
+            ["telemetry_runs.run_id", "telemetry_runs.producer_id"],
+            name="fk_telemetry_events_run",
+        ),
+        Index(
+            "telemetry_events_run_sequence",
+            "run_id",
+            "producer_id",
+            "sequence",
+        ),
+    )
+
+    event_id: Mapped[str] = mapped_column(Text, primary_key=True)
+    run_id: Mapped[str] = mapped_column(Text, nullable=False)
+    producer_id: Mapped[str] = mapped_column(Text, nullable=False)
+    sequence: Mapped[int] = mapped_column(Integer, nullable=False)
+    payload: Mapped[dict[str, Any]] = mapped_column(
+        "payload_json",
+        JsonObjectText,
+        nullable=False,
+    )
+    created_at: Mapped[str] = mapped_column(Text, nullable=False)
+    run: Mapped[TelemetryRunRecord] = relationship(back_populates="events")
+
+
+class GraphPublicationJob(SpoolModel):
+    """Durable artifact delivery, independent of event retention and run IDs."""
+
+    __tablename__ = "graph_publication_jobs"
+    publication_id: Mapped[str] = mapped_column(Text, primary_key=True)
+    inventory: Mapped[dict[str, Any]] = mapped_column(JsonObjectText, nullable=False)
+    directory: Mapped[str] = mapped_column(Text, nullable=False)
+    status: Mapped[str] = mapped_column(Text, nullable=False)
+    attempts: Mapped[int] = mapped_column(Integer, nullable=False)
+    next_attempt_at: Mapped[float] = mapped_column(Float, nullable=False)
+    lease_until: Mapped[float] = mapped_column(Float, nullable=False)
+    receipt: Mapped[dict[str, Any]] = mapped_column(JsonObjectText, nullable=False)

microcosm_emitter/host/__init__.py

@@ -0,0 +1 @@
+"""Generic local service support; importing this package has no side effects."""