generic-ml-cache-core 0.2.0__py3-none-any.whl

generic_ml_cache_core/application/usecase/run_passthrough_execution_service.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""RunPassthroughExecutionService."""
+
+from __future__ import annotations
+
+from typing import Tuple
+
+from generic_ml_cache_core.application.domain.model.identity.call_identity import CallIdentity
+from generic_ml_cache_core.application.domain.model.run.client_run_result import ClientRunResult
+from generic_ml_cache_core.application.domain.model.execution.execution_kind import ExecutionKind
+from generic_ml_cache_core.application.domain.model.identity.passthrough_call_identity import (
+    PassthroughCallIdentity,
+)
+from generic_ml_cache_core.application.port.inbound.run_passthrough_execution_command import (
+    RunPassthroughExecutionCommand,
+)
+from generic_ml_cache_core.application.port.inbound.run_passthrough_execution_use_case import (
+    RunPassthroughExecutionUseCase,
+)
+from generic_ml_cache_core.application.port.out.blob_store_port import BlobStorePort
+from generic_ml_cache_core.application.port.out.execution_repository_port import (
+    ExecutionRepositoryPort,
+)
+from generic_ml_cache_core.application.port.out.metrics_port import MetricsPort
+from generic_ml_cache_core.application.port.out.passthrough_runner_port import PassthroughRunnerPort
+from generic_ml_cache_core.application.usecase.cached_ml_execution_service import (
+    CachedMlExecutionService,
+)
+from generic_ml_cache_core.common.checksum import fingerprint_arguments
+
+
+class RunPassthroughExecutionService(CachedMlExecutionService, RunPassthroughExecutionUseCase):
+    """Record-or-replay a passthrough (alias) client call.
+
+    Implements the inbound port over the shared cached-execution flow, supplying
+    the passthrough specifics: the identity is the client plus a fingerprint of
+    the opaque native args, the client runs via the passthrough runner (no
+    isolation, no file capture), and executions are tagged LOCAL_PASSTHROUGH. A
+    passthrough is always cacheable, so it keeps the base's default.
+    """
+
+    def __init__(
+        self,
+        passthrough_runner: PassthroughRunnerPort,
+        blob_store: BlobStorePort,
+        repository: ExecutionRepositoryPort,
+        metrics: MetricsPort,
+    ) -> None:
+        super().__init__(blob_store, repository, metrics)
+        self._passthrough_runner = passthrough_runner
+
+    def _build_identity(self, command: RunPassthroughExecutionCommand) -> CallIdentity:
+        return PassthroughCallIdentity(
+            client=command.client,
+            native_args_fingerprint=fingerprint_arguments(command.native_args),
+        )
+
+    def _run_client(self, command: RunPassthroughExecutionCommand) -> ClientRunResult:
+        return self._passthrough_runner.run(command.client, command.native_args)
+
+    def _execution_kind(self) -> ExecutionKind:
+        return ExecutionKind.LOCAL_PASSTHROUGH
+
+    def _journal_fields(self, command: RunPassthroughExecutionCommand) -> Tuple[str, str, str]:
+        # A passthrough has no modelled model/effort — only the client is known.
+        return command.client, "", ""

generic_ml_cache_core/common/__init__.py

@@ -0,0 +1 @@
+"""Cross-cutting leaves shared across the package (errors, checksums, constants)."""

generic_ml_cache_core/common/checksum.py

@@ -0,0 +1,82 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""Container-independent checksumming of cache inputs.
+
+The whole point of this module is one invariant:
+
+    The same *text* must yield the same checksum regardless of how that text
+    happened to be stored -- whether it lived in a standalone file on disk or
+    inside a JSON string field.
+
+We achieve that by hashing the *decoded* UTF-8 text of each field, never the
+bytes of whatever container (file, JSON document) carried it. Newlines, tabs
+and other whitespace are meaningful and are never stripped.
+
+Each field is length-prefixed before hashing so that, e.g., ``{"context": "ab",
+"prompt": "c"}`` can never collide with ``{"context": "a", "prompt": "bc"}``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from typing import Mapping, Sequence
+
+# Control characters used purely as internal framing while hashing. They never
+# touch user data and never appear in the stored record on disk.
+_FIELD_SEP = b"\x1f"  # unit separator
+_RECORD_SEP = b"\x1e"  # record separator
+# Separates ordered arguments before hashing; order is significant (CLI flags
+# are positional), so the join preserves it.
+_ARGUMENT_SEP = "\x00"
+
+
+def text_checksum(text: str) -> str:
+    """SHA-256 of a single decoded string's UTF-8 bytes."""
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def file_content_fingerprint(data: bytes) -> str:
+    """The one shared rule for fingerprinting a declared input file's content.
+
+    SHA-256 of the raw bytes -- binary-safe, so any file type fingerprints the
+    same way regardless of encoding. This is the single function every front
+    door (CLI, daemon, library consumer) must call; it is imported directly,
+    never reimplemented, so two front doors can never derive different keys for
+    the same file and silently miss each other's cache.
+    """
+    return hashlib.sha256(data).hexdigest()
+
+
+def fingerprint_arguments(arguments: Sequence[str]) -> str:
+    """Fingerprint an ordered argument list into the key.
+
+    The raw arguments may carry secrets, so only their digest is ever keyed or
+    stored. Order is significant; the join with a control separator preserves it.
+    """
+    return text_checksum(_ARGUMENT_SEP.join(arguments))
+
+
+def checksum_input_data(input_data: Mapping[str, str]) -> str:
+    """Return the container-independent SHA-256 checksum of ``input_data``.
+
+    ``input_data`` is the cache input mapping, e.g. ``{"context": ..., "prompt":
+    ...}``. Keys are hashed in sorted order so the result does not depend on dict
+    ordering. Values must be ``str`` -- the cache is deliberately *dumb*, so it is
+    the caller's job to make the text deterministic.
+    """
+    digest = hashlib.sha256()
+    for key in sorted(input_data):
+        value = input_data[key]
+        if not isinstance(value, str):
+            raise TypeError(
+                f"input_data[{key!r}] must be str (the cache hashes decoded text, "
+                f"not bytes or objects); got {type(value).__name__}"
+            )
+        encoded = value.encode("utf-8")
+        digest.update(key.encode("utf-8"))
+        digest.update(_FIELD_SEP)
+        digest.update(str(len(encoded)).encode("ascii"))
+        digest.update(_FIELD_SEP)
+        digest.update(encoded)
+        digest.update(_RECORD_SEP)
+    return digest.hexdigest()

generic_ml_cache_core/common/errors.py

@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""Exception types raised by generic-ml-cache."""
+
+from __future__ import annotations
+
+
+class CacheError(Exception):
+    """Base class for all generic-ml-cache errors."""
+
+
+class CacheMiss(CacheError):
+    """Raised in offline mode when no stored execution matches the request.
+
+    Offline mode is a *knowing* switch to replay-only: a miss is an error, never
+    a silent fall-through to a real call.
+    """
+
+
+class UnknownClient(CacheError):
+    """Raised when no adapter is registered for the requested client name."""
+
+
+class ConfigError(CacheError):
+    """Raised when the optional config file or a config env var is invalid.
+
+    A missing config file is never an error -- it just means built-in defaults
+    apply. This is only for a file that exists but cannot be parsed, or a value
+    (mode, timeout) that is not understood.
+    """
+
+
+class ClientNotFound(CacheError):
+    """Raised when the client executable cannot be located on the system."""
+
+
+class CommandLineTooLong(CacheError):
+    """Raised before launch when the assembled command line would exceed the
+    operating system's argument-size limit.
+
+    Only a client that receives the prompt as a command-line argument
+    (cursor-agent, which has no stdin path) can hit this; claude and codex take the
+    prompt on stdin and are unaffected. Raising it up front turns an opaque OS
+    "argument list too long" error (or a silent Windows failure) into a clear
+    message that names the size, the limit, and the remedy.
+    """
+
+
+class InputFileError(CacheError):
+    """Raised when a declared input file cannot be read for fingerprinting.
+
+    The path does not point to a regular file, or the bytes could not be read.
+    The filesystem fingerprint adapter translates the foreign ``OSError`` into
+    this cause-named exception so the core never sees a library error type.
+    """
+
+
+class ArtifactBlobMissing(CacheError):
+    """Raised when hydrating an execution whose artifact references a blob that
+    the blob store no longer holds.
+
+    The structured record says the output was persisted, but the bytes are gone
+    (an out-of-band deletion, a half-completed prune). The engine fails loud
+    rather than returning a silently empty result.
+    """
+
+
+class RunInterrupted(Exception):
+    """Raised when a real client run is stopped by a signal from the caller (the
+    workflow engine) before it finished.
+
+    Deliberately **not** a ``CacheError``: it is not a fault but a requested stop,
+    and it must never be recorded as an execution -- an interrupted call is not a
+    result. The CLI maps it to a distinct exit code so a stop is distinguishable
+    from a failure.
+    """

generic_ml_cache_core/stream.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: 2026 Daniel Slobozian
+# SPDX-License-Identifier: Apache-2.0
+"""Live progress stream: an opt-in NDJSON event file written as a call runs.
+
+The cache is the one running the client, so it is the right place to surface what
+the client is doing *right now* -- for a human watching a long call, and (later)
+for the workflow engine relaying progress to its own user.
+
+Design:
+
+* **Display-only.** The stream never changes what the cache records or the cache
+  key. It is a *view* of the run, not a second source of truth.
+* **A regular file** is the transport. It is the one streaming channel that
+  behaves identically on Linux, macOS and Windows -- no sockets, no named pipes
+  (POSIX-only), no ``select``. A consumer (a human ``tail -f``, or a parent
+  process reading line by line) just opens it read-only and reads new lines.
+* **NDJSON / JSON Lines.** One self-contained JSON object per line, ``\\n``
+  separated, flushed as written, so each event is readable the moment it lands
+  and the file is appendable without parsing what came before.
+* **Best-effort.** A write that fails (full disk, bad path) is dropped, never
+  raised -- a progress view must not be able to break the real call.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+
+class StreamWriter:
+    """Append NDJSON progress events to ``path``. Safe to construct even if the
+    path is unwritable: streaming is then silently disabled and the call runs
+    unaffected."""
+
+    def __init__(self, path: Path) -> None:
+        self._fh: Optional[Any] = None
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            # Text append; newline="\n" writes bare line feeds on every OS (no
+            # CRLF translation), which is what NDJSON consumers expect.
+            self._fh = open(path, "a", encoding="utf-8", newline="\n")
+        except OSError:
+            self._fh = None  # streaming disabled; the run still proceeds
+
+    def event(self, kind: str, **fields: Any) -> None:
+        """Write one event line: ``{"ts": <epoch>, "kind": <kind>, ...}``.
+        Fields that are ``None`` are omitted so the line stays compact."""
+        if self._fh is None:
+            return
+        record = {"ts": round(time.time(), 3), "kind": kind}
+        record.update({k: v for k, v in fields.items() if v is not None})
+        try:
+            self._fh.write(json.dumps(record, ensure_ascii=False) + "\n")
+            self._fh.flush()
+        except (OSError, ValueError, TypeError):
+            pass  # drop the event rather than fail the run
+
+    def close(self) -> None:
+        if self._fh is not None:
+            try:
+                self._fh.close()
+            finally:
+                self._fh = None

generic_ml_cache_core-0.2.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: generic-ml-cache-core
+Version: 0.2.0
+Summary: Hexagonal core library for generic-ml-cache: domain, use cases, ports, and the default outbound adapters (SQLite repo, blob store, local clients, API). Stateless; inject the data source. Zero runtime deps.
+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,hexagonal,library,llm,ports-and-adapters,replay
+Classifier: Development Status :: 3 - Alpha
+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.9
+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.9
+Provides-Extra: dev
+Requires-Dist: coverage>=7; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.15; extra == 'dev'
+Requires-Dist: vulture>=2; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# generic-ml-cache-core
+
+#### The hexagonal engine behind gmlcache — embeddable, stateless, dependency-free
+
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-2563eb?style=flat-square)](https://github.com/danielslobozian/generic-ml-cache/blob/main/LICENSE)
+[![Status: Alpha](https://img.shields.io/badge/Status-Alpha-d97706?style=flat-square)](https://github.com/danielslobozian/generic-ml-cache/blob/main/docs/ROADMAP.md)
+
+The reusable **engine** behind
+[`gmlcache`](https://github.com/danielslobozian/generic-ml-cache/tree/main/packages/cli):
+record a real ML client (or API) call once, replay it by its content key. It contains
+the domain model, the use cases, the port contracts, **and the default outbound
+adapters** (SQLite execution repository, filesystem blob store, the
+claude/codex/cursor client runner, the API client, metrics, clock, fingerprinting) —
+plus the `build_use_cases` composition factory.
+
+Pure Python, **zero runtime dependencies**, and **stateless**: it bakes in *structure*
+(table names, blob naming, schema) but no *location* — you inject the data source.
+
+## Install
+
+```bash
+pip install generic-ml-cache-core
+```
+
+## Embed it
+
+Hand the library a data source and it wires the engine for you:
+
+```python
+from generic_ml_cache_core import build_use_cases
+from generic_ml_cache_core.application.port.inbound.run_managed_local_execution_command import (
+    RunManagedLocalExecutionCommand,
+)
+
+wired = build_use_cases(store_root="/path/you/choose")   # you provide the data source
+command = RunManagedLocalExecutionCommand(
+    client="claude", model="sonnet", effort="", context="", prompt="…",
+)
+execution = wired.run_managed.execute(command)           # records on a miss, replays on a hit
+```
+
+You reuse the shipped adapters by injecting a data source — you never reimplement them
+(the **Spring Batch** model: the framework ships the writers, you provide the
+connection). Need a different store? Construct the use cases yourself against the
+ports and pass your own adapter.
+
+## What's inside
+
+- **Domain model** — executions, polymorphic call identities, artifacts, usage.
+- **Use cases** — managed-local / passthrough / API runs, and probe (check).
+- **Ports** (`application/port/...`) — client runner, blob store, execution repository,
+  metrics, clock, fingerprint, API client.
+- **Default adapters** (`adapter/out/...`) + the `build_use_cases` composition factory.
+- **`generic_ml_cache_core.testing.InMemoryExecutionRepository`** — a dependency-free
+  reference adapter to test your code against the ports.
+
+Inbound drivers —
+[`gmlcache`](https://github.com/danielslobozian/generic-ml-cache/tree/main/packages/cli)
+today, a daemon later — map their surface (a terminal, a REST API) onto these public
+APIs; the core itself has no UI and reads no config file.
+
+## Links
+
+- **Repository & docs:** <https://github.com/danielslobozian/generic-ml-cache>
+- **Changelog** (both packages, versioned in lockstep): [`CHANGELOG.md`](https://github.com/danielslobozian/generic-ml-cache/blob/main/CHANGELOG.md)
+- **Security policy:** [`SECURITY.md`](https://github.com/danielslobozian/generic-ml-cache/blob/main/SECURITY.md)
+
+## 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_core-0.2.0.dist-info/RECORD

@@ -0,0 +1,99 @@
+generic_ml_cache_core/__init__.py,sha256=YFP5MttqlFpwig_h08W_a3QqbwyCD3Jhac60HbFeSbo,2053
+generic_ml_cache_core/stream.py,sha256=a2hIsedn7zqywkBe5cMw-nV5rU02CkTfyEYOJ_ypWIc,2793
+generic_ml_cache_core/adapter/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/inbound/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/inbound/composition.py,sha256=gVmHhSsMtf2D_PHpm5pxJZudnVsXLVexTvfTRQbgm3g,4017
+generic_ml_cache_core/adapter/out/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/out/api/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/out/api/stub_api_client_adapter.py,sha256=KPlpGue5V64XBcZCmZy_NQjowdCajkcTA2rz6VFpugU,1521
+generic_ml_cache_core/adapter/out/client/__init__.py,sha256=54Rt2Fjo_46yhXAM-Xu_TeszJVXvvMRwXJtQq8bbVRQ,978
+generic_ml_cache_core/adapter/out/client/claude.py,sha256=upoXwuzopFIfLimLQCt1CrFhpe6a08-AWdfLgUzZYrY,9310
+generic_ml_cache_core/adapter/out/client/codex.py,sha256=T4uey-iC4AIbKGJMvEfl6mOPgQkR9osBxh9M-m4tgCU,7400
+generic_ml_cache_core/adapter/out/client/cursor.py,sha256=9cstycJXAGm0DfmrmaKCyTPs0aExq1NkBtO1AAIGiZM,9590
+generic_ml_cache_core/adapter/out/client/discover.py,sha256=TUeQQP5M8y8VKUJqCI6Cshvrh1pmTVUwIQrshZpjzFU,4882
+generic_ml_cache_core/adapter/out/client/isolation.py,sha256=q2ON_VOTBPZKnK-CFRuPyr4uSYQYpMoypm1R68-N0Cg,15851
+generic_ml_cache_core/adapter/out/client/local_client_runner.py,sha256=JmNlDFHeFowEfSWFeAyPM6f5X40fzo4H7eXZN222chc,2435
+generic_ml_cache_core/adapter/out/client/passthrough_client_runner.py,sha256=ae7v0AJc2PXTY0vOMPd2gXDU73qcTxVEbAAkgg8APlw,1919
+generic_ml_cache_core/adapter/out/client/prime_directive.py,sha256=S5O8ggEQJWe61QI1IQhFot4qlTsQbuyF7nOgWWVBGms,2525
+generic_ml_cache_core/adapter/out/client/registry.py,sha256=kqKoTxaUbPKcbn3izXdbqSgCbni9ElI0x43ZUhY0KkU,1011
+generic_ml_cache_core/adapter/out/clock/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/out/clock/system_clock.py,sha256=wOhuOmWKF4VAo-7X2ZKOOebhNo2QZJATatmWuwt15MA,466
+generic_ml_cache_core/adapter/out/fingerprint/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/out/fingerprint/filesystem_file_fingerprint.py,sha256=_TErnfPykePUULxXm-uF6AIKJtfVt-pD1d-8BtSCltU,1235
+generic_ml_cache_core/adapter/out/metrics/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/out/metrics/access_registry.py,sha256=oUfI3tzokgohq-irsGhpLdc8wXBZkjQmzkz_qyWz_BU,5286
+generic_ml_cache_core/adapter/out/metrics/journal_metrics.py,sha256=ypP0JAo42sbvtlv2nXGSjE7lAygmONt6tiNuEanudJE,1503
+generic_ml_cache_core/adapter/out/persistence/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/out/persistence/call_identity_serialization.py,sha256=tto1R0n4hy2Tgbvhrs4ugZao44Gvvj47a0FHxDEMJN8,4069
+generic_ml_cache_core/adapter/out/persistence/in_memory_execution_repository.py,sha256=yJ_1CoNU5iLq42kvYTxbEeFMIBIJf9AiFSOlAvH7JsY,3033
+generic_ml_cache_core/adapter/out/persistence/sqlite_execution_repository.py,sha256=sdInMD93fXvdcYSM6NtVHCRk0hS6TtGaS6fz9p_7qt4,15356
+generic_ml_cache_core/adapter/out/storage/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/adapter/out/storage/filesystem_blob_store.py,sha256=KcvDtLkRc8kv04nH_HnmBqjx5hVchW-J3XqCM0Oarcc,1565
+generic_ml_cache_core/application/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/model/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/model/client_status.py,sha256=uSNwPAqvCyit7jknjts_hf6Oq5N5EbbpvanqRQCjFkQ,477
+generic_ml_cache_core/application/domain/model/model_info.py,sha256=Rzyl0WB7Us1ZrEbHOV6tTksQsAu64J2rIf58aiOtMgI,511
+generic_ml_cache_core/application/domain/model/model_listing.py,sha256=fz54OyNNwQZ1yXOsO-U5Z_Sm7fED5tZDeaSNSaPKXgo,860
+generic_ml_cache_core/application/domain/model/parsed_output.py,sha256=kfxYCLtkdMLr4mAv0YSe8rDOOqeIH-mFmHOdS8tm1Bk,738
+generic_ml_cache_core/application/domain/model/execution/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/model/execution/artifact.py,sha256=b1lXMoDxhJIzOiex2u1F5Q9jHGpf9hDMUpF4bugCkBM,2262
+generic_ml_cache_core/application/domain/model/execution/execution_failure.py,sha256=KvUZyLivH6YsjJd5eaZitE21sRW0UJhrFuq_-ulU4-E,931
+generic_ml_cache_core/application/domain/model/execution/execution_kind.py,sha256=_fBpNKWQS8AmcgcTglFzDCIyma9bmalJJteAw__QjbI,1033
+generic_ml_cache_core/application/domain/model/execution/execution_state.py,sha256=N4TNnuRuusr0ROMiHdiOAn-r1zibhznGv2fJOnxGNkg,516
+generic_ml_cache_core/application/domain/model/execution/ml_execution.py,sha256=3GYdv2_mZ36ZYdKMCZK-KhJKHguKDt5heWB3ajSd8Bc,1775
+generic_ml_cache_core/application/domain/model/identity/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/model/identity/api_call_identity.py,sha256=A-RRECEr0B2KxokgOi-iwKCJU3bIQkVggAcIjhX9KAk,1212
+generic_ml_cache_core/application/domain/model/identity/call_identity.py,sha256=Y_XI0mEvhmVaQD51jClgS1nZI8RV4PDoiDK8zEcHcjw,887
+generic_ml_cache_core/application/domain/model/identity/managed_call_identity.py,sha256=3nIqidUEwPxI5WzgFD0x-ZDIzo1wC9yLboxhz6v-UkI,2300
+generic_ml_cache_core/application/domain/model/identity/passthrough_call_identity.py,sha256=oSyRvuukrQRqdG2wf1HTB_TM0f9a8Kcuq8wcO0HxOXo,1285
+generic_ml_cache_core/application/domain/model/probe/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/model/probe/probe_report.py,sha256=JkK1dcY_D2Q7to087Sk5I1Aa1nOf29aFizac5TeSXI8,868
+generic_ml_cache_core/application/domain/model/probe/probe_status.py,sha256=CEDX4hGAEZL36HlKxzOYb08YygFCLwhdZqmSfUwyx2k,381
+generic_ml_cache_core/application/domain/model/run/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/model/run/cache_mode.py,sha256=_DnxIzowMTiZl3gWiuFXWtNI02vayXlOYdfm9iqela4,557
+generic_ml_cache_core/application/domain/model/run/client_run_request.py,sha256=ymp_azgY9D3eU8W-VjP5FiQKHhRtPg980Fi7s-I2AmE,1285
+generic_ml_cache_core/application/domain/model/run/client_run_result.py,sha256=3PwE5rzftECOOhiyq6TdyoRpKIdjY98WKsqWnTNXH_c,2311
+generic_ml_cache_core/application/domain/model/run/message.py,sha256=wqCwlvJAlzE-1R7XXMmIyshj8aJLB21f6x864Td_cLE,562
+generic_ml_cache_core/application/domain/model/usage/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/model/usage/token_usage.py,sha256=r1XTjyBzfoWtg_ZnoNza23YQQm4BBPbgj93L0X6An2E,2186
+generic_ml_cache_core/application/domain/model/usage/usage.py,sha256=A-KZRE0A7rIj0o5VjOVqDFfaJeUpgWUl4EMJ4MBkWao,5037
+generic_ml_cache_core/application/domain/service/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/domain/service/cacheability.py,sha256=59YHGtzle-VEUyXsv79pHwp5qQ3dFoxr2HYM9lXTG8Q,806
+generic_ml_cache_core/application/domain/service/message_fingerprinting.py,sha256=XhnFmvXky2F7eqfYVsGyQo2uGskIv7Jr3_FRjUyBp88,971
+generic_ml_cache_core/application/port/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/port/inbound/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/port/inbound/probe_command.py,sha256=YTz0CFqY-tDIrJFLdItGGdGMNpyGViXSpAzpbpMpqBk,1123
+generic_ml_cache_core/application/port/inbound/probe_use_case.py,sha256=iA1ljXweAz-TArbsmGA6TXmszc-sC1Brfeg59rey9j8,726
+generic_ml_cache_core/application/port/inbound/run_api_execution_command.py,sha256=Le1eIyrSiKQIpV0rHtjoI_9eh5M_pZMPuS5cvAQqzlA,1491
+generic_ml_cache_core/application/port/inbound/run_api_execution_use_case.py,sha256=IipBD4plrpHZTafWaHkSOATxvOJgQ4gDGDSAjZogffc,697
+generic_ml_cache_core/application/port/inbound/run_managed_local_execution_command.py,sha256=ILuvQ5R-HMmL0RMByPkj0GRrmPOQjpFMBmNq5GNAjGM,1760
+generic_ml_cache_core/application/port/inbound/run_managed_local_execution_use_case.py,sha256=xDLfF-02weweXlQRXimZPJUplF5tNtAhabQuN2hW39c,923
+generic_ml_cache_core/application/port/inbound/run_passthrough_execution_command.py,sha256=GtAoe5UXCGPS3_PcJ-PPNQ-upFMMSb-AdrkB7kBdDM0,1239
+generic_ml_cache_core/application/port/inbound/run_passthrough_execution_use_case.py,sha256=T_I7IpB-Qwia6MGg17IJ7kQ-m1bjmhrQjODW_cyiJek,749
+generic_ml_cache_core/application/port/out/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/port/out/api_client_port.py,sha256=16CjfOFjEXFabsVpQq_Gk7X7-MF2qMz2DuKVCsgTNWc,1047
+generic_ml_cache_core/application/port/out/base.py,sha256=_YXmS2xcIJL8U3lzJswAKOM8QrQkY34GP8OnUhGy_Zc,12958
+generic_ml_cache_core/application/port/out/blob_store_port.py,sha256=llWgt3Fsl55MlJGDGoOxHDijDfPHivVqzPqGBbgxA9g,1336
+generic_ml_cache_core/application/port/out/client_runner_port.py,sha256=ZJxMrAcrEtLgdK3yTJe3Cv6bqjI2OjcfIcOMxfQZKKM,1081
+generic_ml_cache_core/application/port/out/clock_port.py,sha256=Ai5JxLlvIaQ8JXKbCWJ_QtZZjkucy6sK25nSddxk7Zw,699
+generic_ml_cache_core/application/port/out/execution_repository_port.py,sha256=j86EyxbzHSaMubFJ3cg1xdx4Vpj3c5blq7oRhhUFYoo,1708
+generic_ml_cache_core/application/port/out/file_fingerprint_port.py,sha256=ZXyJq7LFRVWfgpvYFTraAl5k5iU9vozckEciQ-hDs2U,907
+generic_ml_cache_core/application/port/out/metrics_port.py,sha256=DxHL2eTKa7jd4UV846qcXP9fV8MZjEzo01j5Ja_-QbA,1634
+generic_ml_cache_core/application/port/out/passthrough_runner_port.py,sha256=8wxsdJ3Lj65m0QPjOhm4inf8QqeEFhIZus8Do7cQTMI,968
+generic_ml_cache_core/application/usecase/__init__.py,sha256=nuehNF41p14kRWK8rgjE0dNwDo6-Jqqa4M2wTMTx8Z4,31
+generic_ml_cache_core/application/usecase/cached_ml_execution_service.py,sha256=ZEdtMoYAzOfVFqmNFfZrjIkzHnJtlCNxEtvDQ0aPGCI,8880
+generic_ml_cache_core/application/usecase/call_identity_building.py,sha256=1giUpsOEp_zRuJbhMvvn11f6xvkK_-RJNNif1rNzZZY,2217
+generic_ml_cache_core/application/usecase/journal_events.py,sha256=UrEVD-4hGQxTXQ9btjaazh_zuEqW0wJMjksA9civaRs,710
+generic_ml_cache_core/application/usecase/probe_service.py,sha256=HgiXc6_PFnJF-mXN126h0VnJZleQUMcQGq1j1UaTw80,2040
+generic_ml_cache_core/application/usecase/run_api_execution_service.py,sha256=XoLLpgKR0Sf9-FXKNrUF78__2VkGXMoLA22zLkpLoNM,2907
+generic_ml_cache_core/application/usecase/run_managed_local_execution_service.py,sha256=QCCS3EWfye2pns0YbSfwpwRDSjX49CsScOWIldyoGHQ,3862
+generic_ml_cache_core/application/usecase/run_passthrough_execution_service.py,sha256=x0hI_VE8Cp3cZBWiU7AVZeSJAD4AZ9y6rCZlR7epJEA,3048
+generic_ml_cache_core/common/__init__.py,sha256=joTT8UX3dPEgh1e2GC8gq3crhw0i7C6J-HfS2vnP88Y,85
+generic_ml_cache_core/common/checksum.py,sha256=1p9Yhsh3WmB7r0H5x5zUABMyg7_0D_TwgvxzUtZU-HM,3361
+generic_ml_cache_core/common/errors.py,sha256=aP3Udm7ftusGdQQsrzgXFM9_GHc37Dd60dZy0vMz-XM,2745
+generic_ml_cache_core-0.2.0.dist-info/METADATA,sha256=fGNRAlf4jHyImexYTqQtw99pq3WByCr7PaMn1DzA2Zg,5015
+generic_ml_cache_core-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+generic_ml_cache_core-0.2.0.dist-info/licenses/LICENSE,sha256=de-gfE0q-xTYImzwC3dj3S7BxVhanf6RmIGjo_7y3aw,11357
+generic_ml_cache_core-0.2.0.dist-info/licenses/NOTICE,sha256=hQoAdw5YSwg3GmeY8hmy9nyOh20La-Qc6mre-TKpn5M,329
+generic_ml_cache_core-0.2.0.dist-info/RECORD,,

generic_ml_cache_core-0.2.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