| """Crash-resumable, idempotent completion-token accounting.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| from collections.abc import Iterable |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any |
|
|
| from ..atomic_io import atomic_write_json |
| from ..hashing import canonical_json_hash, is_sha256 |
|
|
|
|
| class LedgerError(RuntimeError): |
| """Raised on cap overflow, identity drift, or corrupted resume state.""" |
|
|
|
|
| @dataclass(frozen=True) |
| class CompletionEntry: |
| completion_id: str |
| token_count: int |
| slot_id: str | None = None |
| generation_index: int | None = None |
| completion_sha256: str | None = None |
|
|
| def to_dict(self) -> dict[str, Any]: |
| row: dict[str, Any] = { |
| "completion_id": self.completion_id, |
| "token_count": self.token_count, |
| } |
| if self.slot_id is not None: |
| row["slot_id"] = self.slot_id |
| if self.generation_index is not None: |
| row["generation_index"] = self.generation_index |
| if self.completion_sha256 is not None: |
| row["completion_sha256"] = self.completion_sha256 |
| return row |
|
|
|
|
| def completion_id(run_id: str, slot_id: str, generation_index: int) -> str: |
| if not run_id or not slot_id: |
| raise LedgerError("run_id and slot_id must be non-empty") |
| if ( |
| isinstance(generation_index, bool) |
| or not isinstance(generation_index, int) |
| or generation_index < 0 |
| ): |
| raise LedgerError("generation_index must be a non-negative integer") |
| return canonical_json_hash( |
| { |
| "schema_version": 1, |
| "run_id": run_id, |
| "slot_id": slot_id, |
| "generation_index": generation_index, |
| } |
| ) |
|
|
|
|
| class CompletionTokenLedger: |
| """Idempotent ledger whose state can be atomically checkpointed and resumed.""" |
|
|
| SCHEMA_VERSION = 1 |
|
|
| def __init__( |
| self, |
| *, |
| run_id: str, |
| max_tokens: int, |
| config_sha256: str | None = None, |
| data_manifest_sha256: str | None = None, |
| comparison_slot_manifest_sha256: str | None = None, |
| ) -> None: |
| if not run_id: |
| raise LedgerError("run_id must be non-empty") |
| if isinstance(max_tokens, bool) or not isinstance(max_tokens, int) or max_tokens <= 0: |
| raise LedgerError("max_tokens must be a positive integer") |
| for name, value in ( |
| ("config_sha256", config_sha256), |
| ("data_manifest_sha256", data_manifest_sha256), |
| ("comparison_slot_manifest_sha256", comparison_slot_manifest_sha256), |
| ): |
| if value is not None and not is_sha256(value): |
| raise LedgerError(f"{name} is not a SHA-256") |
| self.run_id = run_id |
| self.max_tokens = max_tokens |
| self.config_sha256 = config_sha256 |
| self.data_manifest_sha256 = data_manifest_sha256 |
| self.comparison_slot_manifest_sha256 = comparison_slot_manifest_sha256 |
| self._entries: dict[str, CompletionEntry] = {} |
| self._consumed = 0 |
|
|
| @property |
| def consumed_tokens(self) -> int: |
| return self._consumed |
|
|
| @property |
| def remaining_tokens(self) -> int: |
| return self.max_tokens - self._consumed |
|
|
| @property |
| def exhausted(self) -> bool: |
| return self._consumed >= self.max_tokens |
|
|
| @property |
| def completion_count(self) -> int: |
| return len(self._entries) |
|
|
| def record( |
| self, |
| completion_key: str, |
| token_count: int, |
| *, |
| slot_id: str | None = None, |
| generation_index: int | None = None, |
| completion_sha256: str | None = None, |
| ) -> bool: |
| """Record once; exact duplicates are resume-safe no-ops. |
| |
| Returns ``True`` for a new record and ``False`` for an identical replay. |
| Reusing an ID with different metadata is corruption and fails. |
| """ |
|
|
| return self.record_many( |
| [ |
| CompletionEntry( |
| completion_id=completion_key, |
| token_count=token_count, |
| slot_id=slot_id, |
| generation_index=generation_index, |
| completion_sha256=completion_sha256, |
| ) |
| ] |
| )[0] |
|
|
| def record_many(self, entries: Iterable[CompletionEntry]) -> tuple[bool, ...]: |
| pending = list(entries) |
| seen_pending: dict[str, CompletionEntry] = {} |
| results: list[bool] = [] |
| new_tokens = 0 |
| for entry in pending: |
| if not isinstance(entry.completion_id, str) or not entry.completion_id: |
| raise LedgerError("completion_id must be non-empty") |
| if ( |
| isinstance(entry.token_count, bool) |
| or not isinstance(entry.token_count, int) |
| or entry.token_count < 0 |
| ): |
| raise LedgerError("token_count must be a non-negative integer") |
| if entry.generation_index is not None and ( |
| isinstance(entry.generation_index, bool) |
| or not isinstance(entry.generation_index, int) |
| or entry.generation_index < 0 |
| ): |
| raise LedgerError("generation_index must be a non-negative integer") |
| if entry.slot_id is not None and ( |
| not isinstance(entry.slot_id, str) or not entry.slot_id |
| ): |
| raise LedgerError("slot_id must be a non-empty string when supplied") |
| if entry.completion_sha256 is not None and not is_sha256(entry.completion_sha256): |
| raise LedgerError("completion_sha256 must be a SHA-256 when supplied") |
| existing = self._entries.get(entry.completion_id) or seen_pending.get( |
| entry.completion_id |
| ) |
| if existing is not None: |
| if existing != entry: |
| raise LedgerError( |
| f"completion_id {entry.completion_id} was reused with different metadata" |
| ) |
| results.append(False) |
| continue |
| seen_pending[entry.completion_id] = entry |
| new_tokens += entry.token_count |
| results.append(True) |
| if self._consumed + new_tokens > self.max_tokens: |
| raise LedgerError( |
| f"completion-token cap exceeded: {self._consumed}+{new_tokens}>{self.max_tokens}" |
| ) |
| for entry in seen_pending.values(): |
| self._entries[entry.completion_id] = entry |
| self._consumed += new_tokens |
| return tuple(results) |
|
|
| def to_dict(self) -> dict[str, Any]: |
| entries = [self._entries[key].to_dict() for key in sorted(self._entries)] |
| return { |
| "schema_version": self.SCHEMA_VERSION, |
| "run_id": self.run_id, |
| "max_tokens": self.max_tokens, |
| "consumed_tokens": self._consumed, |
| "config_sha256": self.config_sha256, |
| "data_manifest_sha256": self.data_manifest_sha256, |
| "comparison_slot_manifest_sha256": self.comparison_slot_manifest_sha256, |
| "entries": entries, |
| } |
|
|
| def save(self, path: str | Path) -> None: |
| atomic_write_json(path, self.to_dict()) |
|
|
| @classmethod |
| def load( |
| cls, |
| path: str | Path, |
| *, |
| expected_run_id: str | None = None, |
| expected_max_tokens: int | None = None, |
| expected_config_sha256: str | None = None, |
| expected_data_manifest_sha256: str | None = None, |
| expected_comparison_slot_manifest_sha256: str | None = None, |
| ) -> CompletionTokenLedger: |
| source = Path(path) |
| try: |
| value = json.loads(source.read_text(encoding="utf-8")) |
| except (OSError, json.JSONDecodeError) as exc: |
| raise LedgerError(f"cannot load ledger {source}: {exc}") from exc |
| if not isinstance(value, dict) or value.get("schema_version") != cls.SCHEMA_VERSION: |
| raise LedgerError("unsupported ledger schema") |
| try: |
| raw_max_tokens = value.get("max_tokens", 0) |
| if isinstance(raw_max_tokens, bool) or not isinstance(raw_max_tokens, int): |
| raise TypeError("max_tokens is not an integer") |
| ledger = cls( |
| run_id=str(value.get("run_id", "")), |
| max_tokens=raw_max_tokens, |
| config_sha256=value.get("config_sha256"), |
| data_manifest_sha256=value.get("data_manifest_sha256"), |
| comparison_slot_manifest_sha256=value.get("comparison_slot_manifest_sha256"), |
| ) |
| except (TypeError, ValueError, LedgerError) as exc: |
| raise LedgerError(f"invalid ledger header: {exc}") from exc |
| checks = ( |
| ("run_id", expected_run_id, ledger.run_id), |
| ("max_tokens", expected_max_tokens, ledger.max_tokens), |
| ("config_sha256", expected_config_sha256, ledger.config_sha256), |
| ( |
| "data_manifest_sha256", |
| expected_data_manifest_sha256, |
| ledger.data_manifest_sha256, |
| ), |
| ( |
| "comparison_slot_manifest_sha256", |
| expected_comparison_slot_manifest_sha256, |
| ledger.comparison_slot_manifest_sha256, |
| ), |
| ) |
| for name, expected, actual in checks: |
| if expected is not None and expected != actual: |
| raise LedgerError(f"resume {name} mismatch: {actual!r} != {expected!r}") |
|
|
| raw_entries = value.get("entries") |
| if not isinstance(raw_entries, list): |
| raise LedgerError("ledger entries must be a list") |
| entries: list[CompletionEntry] = [] |
| for raw in raw_entries: |
| if not isinstance(raw, dict): |
| raise LedgerError("ledger entry must be an object") |
| try: |
| token_count = raw.get("token_count", -1) |
| generation_index = raw.get("generation_index") |
| if isinstance(token_count, bool) or not isinstance(token_count, int): |
| raise TypeError("token_count is not an integer") |
| if generation_index is not None and ( |
| isinstance(generation_index, bool) or not isinstance(generation_index, int) |
| ): |
| raise TypeError("generation_index is not an integer") |
| entries.append( |
| CompletionEntry( |
| completion_id=str(raw.get("completion_id", "")), |
| token_count=token_count, |
| slot_id=raw.get("slot_id"), |
| generation_index=generation_index, |
| completion_sha256=raw.get("completion_sha256"), |
| ) |
| ) |
| except (TypeError, ValueError) as exc: |
| raise LedgerError(f"invalid ledger entry: {exc}") from exc |
| ledger.record_many(entries) |
| raw_consumed = value.get("consumed_tokens") |
| if isinstance(raw_consumed, bool) or not isinstance(raw_consumed, int): |
| raise LedgerError("ledger consumed_tokens must be an integer") |
| if ledger.consumed_tokens != raw_consumed: |
| raise LedgerError("ledger consumed_tokens does not equal entry sum") |
| return ledger |
|
|
