generic-ml-cache-bootstrap 0.29.0__py3-none-any.whl

generic_ml_cache_bootstrap/discovery/entrypoint_adapter_resolver.py

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""EntryPointAdapterResolver — construct a concrete adapter from its id.
+
+The resolver's counterpart to EntryPointAdapterCatalog: where the catalog reads
+``descriptor()`` to answer "what exists?", the resolver constructs the vetted class
+to answer "give me the implementation." It resolves ONLY from the catalog's
+already-gated classes (X15) — it never enumerates or ``load()``s entry points itself,
+so resolving one adapter can no longer run the import-time code of every installed
+plugin (a non-whitelisted plugin the catalog gated out is never imported). Local
+clients are built with the per-run config; API runners take none.
+"""
+
+from __future__ import annotations
+
+from typing import cast
+
+from generic_ml_cache_core.application.port.outbound.adapter_resolver_port import (
+    AdapterResolverPort,
+)
+from generic_ml_cache_core.application.port.outbound.local_client_port import LocalClientPort
+from generic_ml_cache_core.application.port.outbound.ml_runner_port import MlRunnerPort
+from generic_ml_cache_core.common.errors import UnknownClient
+
+from generic_ml_cache_bootstrap.discovery.entrypoint_adapter_catalog import EntryPointAdapterCatalog
+
+
+class EntryPointAdapterResolver(AdapterResolverPort):
+    """Resolve an ``adapter_id`` to a constructed adapter from the catalog's vetted classes."""
+
+    def __init__(self, catalog: EntryPointAdapterCatalog) -> None:
+        self._catalog = catalog
+
+    def _class_for(self, adapter_id: str) -> type:
+        cls = self._catalog.resolve_class(adapter_id)
+        if cls is None:
+            raise UnknownClient(f"no adapter for id {adapter_id!r}")
+        return cls
+
+    def resolve_local_client(
+        self,
+        adapter_id: str,
+        executable_override: str | None = None,
+        timeout: float | None = None,
+        stream_path: str | None = None,
+    ) -> LocalClientPort:
+        cls = self._class_for(adapter_id)
+        return cast(
+            LocalClientPort,
+            cls(executable_override=executable_override, timeout=timeout, stream_path=stream_path),
+        )
+
+    def resolve_runner(self, adapter_id: str) -> MlRunnerPort:
+        return cast(MlRunnerPort, self._class_for(adapter_id)())

generic_ml_cache_bootstrap/discovery/in_memory_adapter_registry.py

@@ -0,0 +1,97 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""InMemoryAdapterRegistry — programmatic adapter registration (tests, embedding).
+
+The relocated, infrastructure-layer home of the old ``register()`` seam. Tests
+and embedding apps register adapter *classes* here; a composition root then
+exposes them as a StaticAdapterCatalog and resolves them. It carries no
+packaging-discovery — it is just an in-memory map — so core never needs it.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import cast
+
+from generic_ml_cache_core.application.domain.model.catalog.adapter_descriptor import (
+    AdapterDescriptor,
+)
+from generic_ml_cache_core.application.domain.model.execution.execution_kind import ExecutionKind
+from generic_ml_cache_core.application.port.outbound.adapter_catalog_port import AdapterCatalogPort
+from generic_ml_cache_core.application.port.outbound.adapter_resolver_port import (
+    AdapterResolverPort,
+)
+from generic_ml_cache_core.application.port.outbound.local_client_port import LocalClientPort
+from generic_ml_cache_core.application.port.outbound.ml_runner_port import MlRunnerPort
+from generic_ml_cache_core.common.errors import UnknownClient
+
+
+class InMemoryAdapterRegistry(AdapterCatalogPort, AdapterResolverPort):
+    """A map of adapter classes registered in-process, keyed by ``adapter_id``.
+
+    It is a *live* catalog and resolver in one: composition merges it with the
+    entry-point catalog/resolver, and registrations made after that merge are
+    still seen (the merge holds this object, not a snapshot)."""
+
+    def __init__(self) -> None:
+        self._classes: dict[str, type] = {}
+
+    def register(self, cls: type) -> None:
+        """Register an adapter class (must expose a ``descriptor()`` classmethod)."""
+        descriptor = cast(AdapterDescriptor, cls.descriptor())  # type: ignore[attr-defined]
+        self._classes[descriptor.adapter_id] = cls
+
+    def clear(self) -> None:
+        self._classes.clear()
+
+    # ------------------------------------------------------------------
+    # AdapterCatalogPort (live view of the registered classes)
+    # ------------------------------------------------------------------
+
+    def list_adapters(self) -> Sequence[AdapterDescriptor]:
+        return [cast(AdapterDescriptor, cls.descriptor()) for cls in self._classes.values()]  # type: ignore[attr-defined]
+
+    def find_by_client_name(self, client_name: str) -> Sequence[AdapterDescriptor]:
+        return [d for d in self.list_adapters() if d.client_name == client_name]
+
+    def supports(self, client_name: str, mode: ExecutionKind) -> bool:
+        return any(
+            d.client_name == client_name and d.supports_mode(mode) for d in self.list_adapters()
+        )
+
+    def _class_for(self, adapter_id: str) -> type:
+        cls = self._classes.get(adapter_id)
+        if cls is None:
+            raise UnknownClient(f"no adapter for id {adapter_id!r}")
+        return cls
+
+    def resolve_local_client(
+        self,
+        adapter_id: str,
+        executable_override: str | None = None,
+        timeout: float | None = None,
+        stream_path: str | None = None,
+    ) -> LocalClientPort:
+        cls = self._class_for(adapter_id)
+        return cast(
+            LocalClientPort,
+            cls(executable_override=executable_override, timeout=timeout, stream_path=stream_path),
+        )
+
+    def resolve_runner(self, adapter_id: str) -> MlRunnerPort:
+        return cast(MlRunnerPort, self._class_for(adapter_id)())
+
+
+#: Process-wide default registry — the relocation of the old module-level
+#: ``register()`` global. Composition roots merge it with the entry-point catalog.
+_DEFAULT_REGISTRY = InMemoryAdapterRegistry()
+
+
+def register(cls: type) -> None:
+    """Register an adapter class into the process-wide default registry."""
+    _DEFAULT_REGISTRY.register(cls)
+
+
+def default_registry() -> InMemoryAdapterRegistry:
+    """Return the process-wide default in-memory registry."""
+    return _DEFAULT_REGISTRY

generic_ml_cache_bootstrap/discovery/static_adapter_catalog.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""StaticAdapterCatalog — a catalog over a fixed list of descriptors.
+
+Useful for tests, minimal deployments, and as the in-process half of a composite
+(e.g. test fakes registered alongside entry-point adapters). It performs no
+discovery; it simply answers questions over the descriptors it was given.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+
+from generic_ml_cache_core.application.domain.model.catalog.adapter_descriptor import (
+    AdapterDescriptor,
+)
+from generic_ml_cache_core.application.domain.model.execution.execution_kind import ExecutionKind
+from generic_ml_cache_core.application.port.outbound.adapter_catalog_port import AdapterCatalogPort
+
+
+class StaticAdapterCatalog(AdapterCatalogPort):
+    """An AdapterCatalogPort backed by a predefined list of descriptors."""
+
+    def __init__(self, descriptors: Iterable[AdapterDescriptor] = ()) -> None:
+        self._descriptors: list[AdapterDescriptor] = list(descriptors)
+
+    def list_adapters(self) -> Sequence[AdapterDescriptor]:
+        return list(self._descriptors)
+
+    def find_by_client_name(self, client_name: str) -> Sequence[AdapterDescriptor]:
+        return [d for d in self._descriptors if d.client_name == client_name]
+
+    def supports(self, client_name: str, mode: ExecutionKind) -> bool:
+        return any(
+            d.client_name == client_name and d.supports_mode(mode) for d in self._descriptors
+        )

generic_ml_cache_bootstrap/encryption.py

@@ -0,0 +1,82 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""Driver-facing facade for the store-encryption commands (W28).
+
+The CLI's ``gmlcache encrypt / decrypt / rotate / invalidate / status`` commands
+are driver *feature* logic, but running them means constructing concrete crypto
+adapters (the cipher, the manifest store, the store lock, the store encryptor) —
+the ``cli._compose -> adapters.…crypto/persistence`` edges W28 removes. This facade
+owns that wiring in the composition root; the CLI controller keeps only its own
+user-facing concerns (prompts, exit codes, the pip-install hint).
+
+The operations raise the same core errors they always did
+(``EncryptionStateError`` / ``WrongEncryptionToken`` / ``StoreLocked``) for the
+driver to translate, plus a bare ``ImportError`` when the optional ``[encryption]``
+extra is not installed (only the token-minting operations need the cipher).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from generic_ml_cache_adapters.adapter.outbound.crypto.filesystem_encryption_manifest_store import (
+    FilesystemEncryptionManifestStore,
+)
+from generic_ml_cache_adapters.adapter.outbound.crypto.store_encryptor import StoreEncryptor
+from generic_ml_cache_adapters.adapter.outbound.persistence.filesystem_store_lock import (
+    FilesystemStoreLock,
+)
+from generic_ml_cache_core.application.domain.model.encryption.encryption_state import (
+    EncryptionState,
+)
+from generic_ml_cache_core.application.port.outbound.cipher_port import CipherPort
+
+
+def _load_cipher() -> CipherPort:
+    """Construct the AES-GCM cipher. Raises ``ImportError`` if the optional
+    ``[encryption]`` extra (the ``cryptography`` dependency) is not installed."""
+    from generic_ml_cache_adapters.adapter.outbound.crypto.aesgcm_cipher import AesGcmCipher
+
+    return AesGcmCipher()
+
+
+class StoreEncryptionOps:
+    """Composition-root facade for the store-encryption operations, so a driver can
+    run the encrypt commands without importing any concrete crypto adapter."""
+
+    def __init__(self, store_root: Path) -> None:
+        self._store_root = Path(store_root)
+
+    def status(self) -> EncryptionState:
+        """The store's current encryption state (no cipher needed)."""
+        return FilesystemEncryptionManifestStore(self._store_root).state()
+
+    def enable(self) -> str:
+        """Enable encryption and return the freshly minted token (shown once)."""
+        cipher = _load_cipher()
+        token = cipher.generate_token()
+        self._encryptor(cipher).enable(token)
+        return token
+
+    def disable(self, token: str) -> None:
+        """Decrypt the store back to plaintext with the current token."""
+        self._encryptor(_load_cipher()).disable(token)
+
+    def rotate(self, old_token: str) -> str:
+        """Rotate to a freshly minted token and return it (shown once)."""
+        cipher = _load_cipher()
+        new_token = cipher.generate_token()
+        self._encryptor(cipher).rotate(old_token, new_token)
+        return new_token
+
+    def invalidate(self) -> None:
+        """Crypto-shred: wipe the cache and return the store to empty + public."""
+        self._encryptor().invalidate()
+
+    def _encryptor(self, cipher: CipherPort | None = None) -> StoreEncryptor:
+        return StoreEncryptor(
+            self._store_root,
+            FilesystemEncryptionManifestStore(self._store_root),
+            FilesystemStoreLock(self._store_root),
+            cipher,
+        )

generic_ml_cache_bootstrap/persistence_backend.py

@@ -0,0 +1,129 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""PersistenceBackend — the DB-backed outbound adapters, bundled as one unit (V33).
+
+The repository, the call journal, and the migration adapter all share ONE database
+through ONE connection FACTORY (each operation opens its own connection from it), so
+they are an atomic unit — you cannot have a Postgres repository and a SQLite journal
+"for the same store". Grouping them into a single injected bundle kills the bare
+``conn_factory`` seam that C-1 exposed: once the dialect layer is gone, a free
+connection factory is a *crossable* seam (a Postgres factory handed to SQLite-dialect
+adapters explodes at runtime). Here the connection factory is owned by / constructed
+with the dialect adapters, never handed across.
+
+The bundle is composition plumbing, NOT a hexagonal port: it is a frozen dataclass
+of the individual core outbound ports (the same shape as ``ApplicationApi`` on the
+inbound side). Core still owns and injects each port one by one — the core never
+sees a "backend"; the bundle exists only at composition time. Both the bundle type
+and the shipped ``sqlite_persistence_backend`` factory live here in bootstrap
+(never in adapters — a factory in adapters returning a bootstrap type would invert
+``adapters ──▶ bootstrap``); adapters ship only the leaf classes.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import cast
+
+from generic_ml_cache_adapters.adapter.outbound.clock.system_clock import SystemClock
+from generic_ml_cache_adapters.adapter.outbound.metrics.access_registry import AccessRegistry
+from generic_ml_cache_adapters.adapter.outbound.metrics.journal_metrics import JournalMetrics
+from generic_ml_cache_adapters.adapter.outbound.persistence.sqlite.execution_repository import (
+    SqliteExecutionRepository,
+)
+from generic_ml_cache_adapters.datasource import sqlite_connection_factory
+from generic_ml_cache_adapters.db import DbConnection
+from generic_ml_cache_adapters.migration_runner import SqliteStoreMigration
+from generic_ml_cache_core.application.port.outbound.call_journal_ports import (
+    CallStatsPort,
+    PurgeJournalPort,
+    RecordCallEventPort,
+    SessionQueryPort,
+    SessionReportSourcePort,
+    SessionSpecPort,
+    SessionTagsPort,
+)
+from generic_ml_cache_core.application.port.outbound.diagnostics_port import DiagnosticsPort
+from generic_ml_cache_core.application.port.outbound.ml_run_ports import (
+    AnnotateMlRunPort,
+    InspectMlRunsPort,
+    PurgeMlRunsPort,
+    ReadMlRunPort,
+    SaveMlRunPort,
+)
+from generic_ml_cache_core.application.port.outbound.repair_ml_runs_port import RepairMlRunsPort
+from generic_ml_cache_core.application.port.outbound.store_migration_port import StoreMigrationPort
+
+
+@dataclass(frozen=True)
+class PersistenceBackend:
+    """The DB-backed outbound ports, grouped so they share one datasource.
+
+    One field per outbound port the use-case graph consumes (mirrors ApplicationApi
+    on the inbound side). The shipped ``sqlite_persistence_backend`` binds one
+    ``SqliteExecutionRepository`` instance to every ``*_ml_run(s)`` field and one
+    ``JournalMetrics`` instance to every journal field — one impl, many role ports
+    (V32/B-1). An embedder replacing the DB implements these ports over their own
+    store and packs their own backend.
+    """
+
+    # the execution repository's role ports
+    save_ml_run: SaveMlRunPort
+    read_ml_run: ReadMlRunPort
+    annotate_ml_run: AnnotateMlRunPort
+    inspect_ml_runs: InspectMlRunsPort
+    purge_ml_runs: PurgeMlRunsPort
+    repair_ml_runs: RepairMlRunsPort
+    # the call journal's role ports
+    record_call_event: RecordCallEventPort
+    call_stats: CallStatsPort
+    session_report_source: SessionReportSourcePort
+    session_query: SessionQueryPort
+    purge_journal: PurgeJournalPort
+    session_tags: SessionTagsPort
+    session_spec: SessionSpecPort
+    # the whole-store migration contract
+    migration: StoreMigrationPort
+
+
+def sqlite_persistence_backend(
+    db_path: Path,
+    diag: DiagnosticsPort | None = None,
+    *,
+    check_same_thread: bool = True,
+) -> PersistenceBackend:
+    """The shipped SQLite persistence backend: repository + journal + migration over
+    one SQLite connection factory (owned here, never exposed).
+
+    ``check_same_thread=False`` for a multi-threaded driver (the daemon's async pool);
+    the default single-threaded ``True`` suits the CLI. The clock is internal — only
+    the repository uses it (to stamp supersession / ``persisted_at``)."""
+    conn_factory = cast(
+        "Callable[[], DbConnection]",
+        sqlite_connection_factory(db_path, check_same_thread=check_same_thread),
+    )
+    clock = SystemClock()
+    repository = SqliteExecutionRepository(conn_factory, clock)
+    journal = JournalMetrics(AccessRegistry(conn_factory, diag=diag))
+    # store_root = the DB's directory, holding ``store.lock`` — lets the migration run
+    # under the blocking-exclusive store lock so a concurrent first-init is serialized
+    # (Y1) rather than racing to double-seed schema_version or collide on the DDL.
+    migration = SqliteStoreMigration(conn_factory, diag, store_root=db_path.parent)
+    return PersistenceBackend(
+        save_ml_run=repository,
+        read_ml_run=repository,
+        annotate_ml_run=repository,
+        inspect_ml_runs=repository,
+        purge_ml_runs=repository,
+        repair_ml_runs=repository,
+        record_call_event=journal,
+        call_stats=journal,
+        session_report_source=journal,
+        session_query=journal,
+        purge_journal=journal,
+        session_tags=journal,
+        session_spec=journal,
+        migration=migration,
+    )

generic_ml_cache_bootstrap/progress.py

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""Driver-facing hook for the live-progress stream (W28).
+
+The NDJSON progress writer is an adapter concern — it opens files, so it lives in
+the ``adapters`` package (and core's raw-I/O guard keeps it out of the pure core).
+A *driver* that also needs to write the same event log (the CLI's async-jobs
+runner appends job events in the run-stream format so ``watch`` reads one log) must
+not import that adapter directly — that is the exact ``cli -> adapters`` edge W28
+removes. Instead it reaches the writer through this composition-root hook: the
+driver depends on ``bootstrap``, ``bootstrap`` owns the wiring to ``adapters``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from generic_ml_cache_adapters.stream import StreamWriter
+
+
+def open_progress_stream(path: Path) -> StreamWriter:
+    """Open a best-effort NDJSON progress writer at ``path``.
+
+    Safe to call even if ``path`` is unwritable: streaming is then silently
+    disabled and the caller's writes are dropped, never raised.
+    """
+    return StreamWriter(path)

generic_ml_cache_bootstrap/store_status.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""Driver-facing read-only store-status probe (W28, folds W26).
+
+The CLI's ``gmlcache doctor`` reports the store's applied migrations. It used to do
+so by handing the read-write ``sqlite_connection_factory`` to a mutating status
+helper — which created the store directory, the database file, and the
+``schema_version`` table as a side effect. A *status probe* must never initialize the
+store it inspects (W26): a mistyped store path would silently spawn an empty store.
+
+This hook does it read-only: an absent database file reports "unmigrated" without
+touching the filesystem; a present one is opened ``mode=ro`` and read, never
+created. It also keeps ``doctor`` free of any direct ``adapters`` import (W28) — the
+driver depends on ``bootstrap``, ``bootstrap`` owns the wiring to ``adapters``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import cast
+
+from generic_ml_cache_adapters.datasource import sqlite_connection_factory
+from generic_ml_cache_adapters.db import DbConnection
+from generic_ml_cache_adapters.migration_runner import applied_schema_version
+
+_DB_NAME = "executions.sqlite3"
+
+
+def applied_migrations(store_root: Path) -> list[dict[str, str]]:
+    """Report the store's applied migrations without initializing it.
+
+    Absent database file → ``[]`` (unmigrated), no filesystem touch; present → open
+    the database read-only and read the applied migrations, never ``CREATE``.
+    """
+    db_path = Path(store_root) / _DB_NAME
+    if not db_path.exists():
+        return []
+    factory = cast("Callable[[], DbConnection]", sqlite_connection_factory(db_path, read_only=True))
+    return applied_schema_version(factory)

generic_ml_cache_bootstrap/stub_runners.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""Driver-facing hook for the CLI's no-credential stub mode (W28).
+
+When the CLI is invoked without selecting a client, every API client name is
+served by the in-process stub adapter — it records/replays a canned response with
+no live call, so demos and cache tests exercise the full pipeline without real
+credentials. Constructing that concrete stub adapter is the last direct
+``cli._compose -> adapters.adapter.outbound`` edge W28 removes; the driver asks the
+composition root for the stub-runner map instead.
+"""
+
+from __future__ import annotations
+
+from typing import cast
+
+from generic_ml_cache_adapters.adapter.outbound.api.stub_api_client_adapter import (
+    StubApiClientAdapter,
+)
+from generic_ml_cache_core.application.domain.model.catalog.adapter_boundary import AdapterBoundary
+from generic_ml_cache_core.application.port.outbound.adapter_catalog_port import AdapterCatalogPort
+from generic_ml_cache_core.application.port.outbound.registered_adapter_port import (
+    RegisteredAdapterPort,
+)
+
+
+def stub_api_runners(catalog: AdapterCatalogPort) -> dict[str, RegisteredAdapterPort]:
+    """Map every API client name in the catalog to one in-process stub adapter."""
+    stub = cast("RegisteredAdapterPort", StubApiClientAdapter())
+    return {
+        descriptor.client_name: stub
+        for descriptor in catalog.list_adapters()
+        if descriptor.boundary is AdapterBoundary.API
+    }

generic_ml_cache_bootstrap-0.29.0.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: generic-ml-cache-bootstrap
+Version: 0.29.0
+Summary: Composition root and plugin discovery for generic-ml-cache: discovers gmlcache.adapters plugins (with load-time whitelisting and provenance trust) and wires the application.
+Project-URL: Homepage, https://github.com/danielslobozian/generic-ml-cache
+Project-URL: Repository, https://github.com/danielslobozian/generic-ml-cache
+Project-URL: Issues, https://github.com/danielslobozian/generic-ml-cache/issues
+Project-URL: Changelog, https://github.com/danielslobozian/generic-ml-cache/blob/main/CHANGELOG.md
+Author: Daniel Slobozian
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: ai,cache,composition-root,discovery,hexagonal,llm,plugins
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: generic-ml-cache-adapters==0.29.*
+Requires-Dist: generic-ml-cache-core==0.29.*
+Provides-Extra: dev
+Requires-Dist: coverage>=7; extra == 'dev'
+Requires-Dist: import-linter>=2; extra == 'dev'
+Requires-Dist: pyright>=1.1; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-timeout; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.15; extra == 'dev'
+Provides-Extra: encryption
+Requires-Dist: generic-ml-cache-adapters[encryption]==0.29.*; extra == 'encryption'
+Description-Content-Type: text/markdown
+
+# generic-ml-cache-bootstrap
+
+#### The composition root and plugin discovery for gmlcache
+
+The startup layer that assembles the application. It discovers the
+`gmlcache.adapters` plugins (whitelisting them at load time and judging which
+distributions are trusted), then wires the [core](https://github.com/danielslobozian/generic-ml-cache/tree/main/packages/core)
+use cases to the concrete [adapters](https://github.com/danielslobozian/generic-ml-cache/tree/main/packages/adapters)
+and hands the drivers a ready application API.
+
+It is the one place that freely wires both `core` and `adapters` — the
+composition root in hexagonal terms. The drivers
+([cli](https://github.com/danielslobozian/generic-ml-cache/tree/main/packages/cli),
+daemon) get their wired application from `bootstrap` and reach the domain only
+through the inbound ports of that `ApplicationApi` bundle; the DB-backed adapters
+are grouped behind an injectable `PersistenceBackend`, so no driver ever touches a
+raw connection. A driver keeps only a few deliberate *direct* edges to `adapters`,
+each a driver-policy choice rather than domain wiring: the CLI's own
+`encrypt`/`decrypt`/`rotate` command helpers (the crypto adapters) and its demo
+stub adapter, and each driver selecting its own diagnostics (logging) adapter.
+An adapter never imports `bootstrap` (that would be a leaf calling the composition
+root). These edges are frozen by import-linter contracts.
+
+## Install
+
+You normally get it transitively (`pip install generic-ml-cache-cli` pulls it
+in). Installed on its own:
+
+```bash
+pip install generic-ml-cache-bootstrap
+```
+
+## License
+
+Apache-2.0 — see [`LICENSE`](https://github.com/danielslobozian/generic-ml-cache/blob/main/LICENSE)
+and [`NOTICE`](https://github.com/danielslobozian/generic-ml-cache/blob/main/NOTICE).

generic_ml_cache_bootstrap-0.29.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+generic_ml_cache_bootstrap/__init__.py,sha256=o_WpASTjKfguUGrMS1AQ53YR6zynJwo9K0HqO9_lxkM,1124
+generic_ml_cache_bootstrap/application.py,sha256=qBt_4qOIThe_wwiw5X4J_miMXSjUwv3HYHcSToBPcCU,12988
+generic_ml_cache_bootstrap/diagnostics.py,sha256=FeQaAT7lPtqA8QbErzgHvOPdxPPmAPzl5XoHyy52Lzg,1750
+generic_ml_cache_bootstrap/encryption.py,sha256=tTIA3HIp-T4YXG4IOW_AuESAQQme_k3FUmPd5s8jBXk,3480
+generic_ml_cache_bootstrap/persistence_backend.py,sha256=TUKivdVIbsUfr6anaip3MsPr8A5ZvXKe6bjkZBaKnYU,5786
+generic_ml_cache_bootstrap/progress.py,sha256=x1xXBa_af9_pbwPkBfojMvXQUydWDIbS7PCMoDMX568,1138
+generic_ml_cache_bootstrap/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+generic_ml_cache_bootstrap/store_status.py,sha256=P8NyaF8srEkMr3AFsutdTx3UR8y1R4xGFed9RDkoV-s,1799
+generic_ml_cache_bootstrap/stub_runners.py,sha256=rPMCOQgnr8kvoomvEx_D1Vm7fHcs4Uyfw02BZk0TOpk,1491
+generic_ml_cache_bootstrap/discovery/__init__.py,sha256=r8hplqEchFcwDwXgPBKLT6FmNtLbgQQBdofFzwZmZhc,403
+generic_ml_cache_bootstrap/discovery/_entrypoints.py,sha256=R2eBCT7oAH16NqC0jkAe20VnXeTuhMyb-53uaRKXOd4,1509
+generic_ml_cache_bootstrap/discovery/api_discover.py,sha256=yq8fsHLUugF7blqYNOBnJ-WIHO9YN6lYriv8wux9QjU,2275
+generic_ml_cache_bootstrap/discovery/client_discover.py,sha256=ENsg0rETyiGyjEJDAtapDIH0X8_6wqcWSZ9nqSfEPoo,9875
+generic_ml_cache_bootstrap/discovery/composite_adapter_catalog.py,sha256=Sv8y4e8F61NNwciC8k3zxXmnm4O-newM8J-yeE0T1i8,1627
+generic_ml_cache_bootstrap/discovery/composite_adapter_resolver.py,sha256=PTTin0z3aX0c1GGxZWGbxEQCF2a9jwqm2rjm_9p_lCs,1978
+generic_ml_cache_bootstrap/discovery/composition.py,sha256=u7TV6J8iQMEflfCZfDEEioqZuJq3bjGoqioGzajaDog,6585
+generic_ml_cache_bootstrap/discovery/entrypoint_adapter_catalog.py,sha256=jshTpep829PbiAyXzfnnDvLpWhf7V2ApSRayPxKtnmE,7206
+generic_ml_cache_bootstrap/discovery/entrypoint_adapter_resolver.py,sha256=lAye9rB09OA1L69qwXCbCOJymqKDAVJIjw0QkFOvW6w,2266
+generic_ml_cache_bootstrap/discovery/in_memory_adapter_registry.py,sha256=Ba1irjFWHGrdtd3U6PtF5OpfrHAu-uYI-Z7CXj0qaTI,4054
+generic_ml_cache_bootstrap/discovery/static_adapter_catalog.py,sha256=wpjE7IJVeQonJDwEWtrHSaBxms-N14PM1NaBEaQgIqI,1526
+generic_ml_cache_bootstrap-0.29.0.dist-info/METADATA,sha256=7-0tEMK83Bv2sVCIpyQodpQopePAEzkXWOpKuMDm50w,3654
+generic_ml_cache_bootstrap-0.29.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+generic_ml_cache_bootstrap-0.29.0.dist-info/licenses/LICENSE,sha256=de-gfE0q-xTYImzwC3dj3S7BxVhanf6RmIGjo_7y3aw,11357
+generic_ml_cache_bootstrap-0.29.0.dist-info/licenses/NOTICE,sha256=hQoAdw5YSwg3GmeY8hmy9nyOh20La-Qc6mre-TKpn5M,329
+generic_ml_cache_bootstrap-0.29.0.dist-info/RECORD,,

generic_ml_cache_bootstrap-0.29.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any