simulo-interfaces 0.1.0__py3-none-any.whl

simulo/interfaces/runtime/anomaly.py

@@ -0,0 +1,195 @@
+"""Anomaly-capture contracts (``DebugOnAnomaly``) — the *local* half of Rule #10.
+
+Training/inference anomaly detection + capture is a **runtime** concern: the
+backend trainer/env detect an anomalous training signal (non-finite loss,
+reward collapse, physics/observation explosion) and capture a bounded MCAP
+debug session locally, via the same recording seam — and therefore the same
+storage/retrieval path — as policy rollout recordings.
+
+The *remote* debug/replay sessions (attach to a live cloud job, replay a
+recorded run, clone-to-debug) remain the FORWARD Protocols in
+:mod:`simulo.interfaces.platform.debug` (``DebugSessionProtocol`` et al.);
+their semantics depend on the cloud debug-session design, which does not exist
+yet. :class:`AnomalyDebugSessionProtocol` here is deliberately narrower — a
+handle to a completed local capture artifact — and is NOT a replacement for
+the platform ``DebugSessionProtocol``.
+
+Torch-free by construction (Rule #11): thresholds and signal values are plain
+floats; the tensor-facing detection lives in the implementer package
+(``simulo.recording.anomaly`` in ``simulo-backend``).
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any, Mapping, Protocol, Sequence, runtime_checkable
+
+
+class AnomalyKind(StrEnum):
+    """Kind of a detected training/inference anomaly.
+
+    Values are a stable wire ABI (they appear in MCAP debug-session payloads
+    and file names): append-only, never rename or renumber.
+
+    The 4-kind set is intentional: a finite-gradient check (``NON_FINITE_GRAD``)
+    is a deliberate deferral, to be appended when a detection site exists.
+    """
+
+    NON_FINITE_LOSS = "non_finite_loss"
+    NON_FINITE_REWARD = "non_finite_reward"
+    REWARD_COLLAPSE = "reward_collapse"
+    OBSERVATION_EXPLOSION = "observation_explosion"
+
+
+@dataclass(frozen=True, kw_only=True)
+class AnomalySignal:
+    """A single detected anomaly, as handed to the capture path.
+
+    ``value``/``baseline`` are plain floats and MAY be non-finite (a NaN loss
+    signal carries the NaN) — serializers must JSON-stringify them rather than
+    emitting raw NaN/Inf tokens.
+    """
+
+    kind: AnomalyKind
+    message: str
+    step_index: int | None = None
+    iteration: int | None = None
+    value: float | None = None
+    baseline: float | None = None
+    env_indices: tuple[int, ...] = ()
+    detected_at: str = ""  # ISO 8601 UTC, stamped by the detector
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, kw_only=True)
+class DebugOnAnomaly:
+    """Configuration for anomaly detection + local MCAP debug-session capture.
+
+    The feature is **off by default** at the integration point: a trainer
+    constructed without a ``DebugOnAnomaly`` (or with ``enabled=False``) runs
+    the exact pre-feature code path — no monitor object exists, no buffering
+    happens, and no file is ever written.
+
+    Signals (deliberately not a bare threshold hack — each maps to a distinct
+    failure mode with its own detection site):
+
+    * ``NON_FINITE_LOSS`` — NaN/Inf policy or value loss mean at a trainer
+      chunk boundary (``check_losses``).
+    * ``NON_FINITE_REWARD`` — NaN/Inf reward at an env step, or a non-finite
+      mean episode reward at a chunk boundary.
+    * ``REWARD_COLLAPSE`` — the chunk's mean episode reward drops by at least
+      ``collapse_drop_fraction`` of the running best baseline (the same
+      best-checkpoint signal the trainer already tracks), sustained for
+      ``collapse_patience`` consecutive chunk boundaries
+      (``check_reward_collapse``).
+    * ``OBSERVATION_EXPLOSION`` — non-finite observations, or observations
+      whose magnitude exceeds ``observation_limit``, at an env step
+      (``check_observations``).
+
+    Video evidence (``video``): naming a camera sensor (e.g.
+    ``video="side_cam"``) additionally buffers that camera's frames for the
+    FIRST watched env (``env_indices[0]``) alongside the numeric window, and
+    a capture writes them into the same debug MCAP (``/debug/window/video``
+    plus a ``foxglove.CompressedVideo`` sibling) so a viewer shows what the
+    sim looked like in the window ending at the anomalous step.
+
+    Honest costs of ``video`` (both opt-in, like the monitor itself):
+
+    * attaching a camera to a training env forces the render pipeline ON
+      during training (the env must be built with cameras enabled), which
+      slows every step whether or not an anomaly ever fires;
+    * the frame ring buffer holds up to ``window_steps`` raw RGB frames in
+      host memory — ``window_steps x H x W x 3`` bytes (64 frames of
+      640x480 is ~56 MiB). Size ``window_steps`` and the camera resolution
+      together.
+
+    ``video=None`` (the default) buffers no frames, resolves no camera, and
+    changes nothing about the numeric-only behavior.
+    """
+
+    enabled: bool = True
+    output_dir: str = "runs/debug"
+    # Bounded pre-anomaly evidence window (in checked env steps) captured
+    # into the debug MCAP.
+    window_steps: int = 256
+    # Env indices whose full observation/reward rows are buffered (aggregate
+    # stats always cover all envs).
+    env_indices: Sequence[int] = (0,)
+    # --- env-step signals -------------------------------------------------
+    check_observations: bool = True
+    # Out-of-envelope magnitude threshold; None disables the envelope check
+    # (non-finite detection stays on while check_observations is True).
+    observation_limit: float | None = 1e6
+    # Check (and buffer) every Nth env step; 1 = every step.
+    check_every_n_steps: int = 1
+    # Name of ONE camera sensor whose frames are buffered as video evidence
+    # for env_indices[0] (see the class docstring for the honest costs).
+    # None (the default) disables video evidence entirely.
+    video: str | None = None
+    # --- chunk-boundary signals -------------------------------------------
+    check_losses: bool = True
+    check_reward_collapse: bool = True
+    # Relative drop vs the running best baseline that counts as a collapse:
+    # (best - current) / max(|best|, collapse_baseline_floor).
+    collapse_drop_fraction: float = 0.5
+    # Consecutive collapsed chunk boundaries required before capturing.
+    collapse_patience: int = 2
+    # Denominator floor so a near-zero best baseline cannot divide away.
+    collapse_baseline_floor: float = 1e-6
+    # Total capture budget; the monitor disarms after this many captures.
+    max_captures: int = 1
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "env_indices", tuple(int(i) for i in self.env_indices))
+        for i in self.env_indices:
+            if i < 0:
+                raise ValueError(f"env_indices must be non-negative, got {i}.")
+        if self.window_steps < 1:
+            raise ValueError(f"window_steps must be >= 1, got {self.window_steps}.")
+        if self.check_every_n_steps < 1:
+            raise ValueError(f"check_every_n_steps must be >= 1, got {self.check_every_n_steps}.")
+        if self.max_captures < 1:
+            raise ValueError(f"max_captures must be >= 1, got {self.max_captures}.")
+        if self.collapse_patience < 1:
+            raise ValueError(f"collapse_patience must be >= 1, got {self.collapse_patience}.")
+        if not (0.0 < self.collapse_drop_fraction <= 1.0):
+            raise ValueError(f"collapse_drop_fraction must be in (0, 1], got {self.collapse_drop_fraction}.")
+        if not (math.isfinite(self.collapse_baseline_floor) and self.collapse_baseline_floor > 0.0):
+            raise ValueError(
+                f"collapse_baseline_floor must be a finite positive float, got {self.collapse_baseline_floor}."
+            )
+        if self.observation_limit is not None and not (
+            math.isfinite(self.observation_limit) and self.observation_limit > 0.0
+        ):
+            raise ValueError(
+                f"observation_limit must be a finite positive float or None, got {self.observation_limit}."
+            )
+        if self.video is not None and (not isinstance(self.video, str) or not self.video.strip()):
+            raise ValueError(f"video must be a non-empty camera sensor name or None, got {self.video!r}.")
+
+
+@runtime_checkable
+class AnomalyDebugSessionProtocol(Protocol):
+    """Handle to a completed local anomaly capture (an MCAP debug session).
+
+    Minimal by design: the artifact is a plain MCAP file a user opens in
+    Lichtblick / Foxglove or reads with the ``mcap`` package. Interactive
+    remote debug sessions are the FORWARD ``DebugSessionProtocol`` in
+    :mod:`simulo.interfaces.platform.debug`.
+    """
+
+    @property
+    def signal(self) -> AnomalySignal:
+        """The anomaly that triggered this capture."""
+        ...
+
+    @property
+    def mcap_path(self) -> str:
+        """Path of the written MCAP debug-session file."""
+        ...
+
+    def close(self) -> None:
+        """Release any resources held by the session (idempotent)."""
+        ...

simulo/interfaces/runtime/components.py

@@ -0,0 +1,35 @@
+"""Observation / reward / termination component Protocols (Part A).
+
+Structural mirrors of ``simulo.core.observations.ObservationComponent``,
+``simulo.core.rewards.RewardComponent``, and
+``simulo.core.terminations.TerminationCondition``.
+"""
+
+from typing import Any, Optional, Protocol, runtime_checkable
+
+from simulo.interfaces.runtime.tensors import TensorLike
+
+
+@runtime_checkable
+class ObservationComponentProtocol(Protocol):
+    """Mirror of ``simulo.core.observations.ObservationComponent``."""
+
+    def initialize(self, robot: Any, device: str, num_envs: int) -> None: ...
+    def dim(self, robot: Any) -> int: ...
+    def compute(self, prev_actions: TensorLike) -> TensorLike: ...
+
+
+@runtime_checkable
+class RewardComponentProtocol(Protocol):
+    """Mirror of ``simulo.core.rewards.RewardComponent``."""
+
+    def initialize(self, robot: Any, device: str, num_envs: int) -> None: ...
+    def compute(self, prev_actions: TensorLike, terminated: Optional[TensorLike]) -> TensorLike: ...
+
+
+@runtime_checkable
+class TerminationConditionProtocol(Protocol):
+    """Mirror of ``simulo.core.terminations.TerminationCondition``."""
+
+    def initialize(self, robot: Any, device: str, num_envs: int) -> None: ...
+    def check(self) -> TensorLike: ...

simulo/interfaces/runtime/env.py

@@ -0,0 +1,27 @@
+"""``LearningEnvProtocol`` — structural mirror of ``simulo.core.env.LearningEnv`` (Part A)."""
+
+from typing import Any, Dict, Optional, Protocol, Tuple, runtime_checkable
+
+from simulo.interfaces.runtime.tensors import TensorLike
+
+
+@runtime_checkable
+class LearningEnvProtocol(Protocol):
+    """Gym-like vectorized env. Mirror of ``simulo.core.env.LearningEnv``."""
+
+    # Plain data member (not a read-only property): the implementation,
+    # ``simulo.core.env.LearningEnv``, exposes ``num_envs`` as an instance
+    # attribute assigned in ``__init__``. Mirror fidelity matters under nominal
+    # conformance — a read-only property here would make the implementer's
+    # ``self.num_envs = num_envs`` an illegal assignment.
+    num_envs: int
+
+    @property
+    def device(self) -> str: ...
+    @property
+    def dt(self) -> float: ...
+    def reset(
+        self, seed: Optional[int] = ..., options: Optional[Dict[str, Any]] = ...
+    ) -> Tuple[TensorLike, Dict[str, Any]]: ...
+    def step(self, actions: TensorLike) -> Tuple[TensorLike, TensorLike, TensorLike, TensorLike, Dict[str, Any]]: ...
+    def close(self) -> None: ...

simulo/interfaces/runtime/player.py

@@ -0,0 +1,19 @@
+"""``PlayerProtocol`` — structural mirror of ``simulo.core.player.Player`` (Part A)."""
+
+from typing import Any, Dict, Optional, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class PlayerProtocol(Protocol):
+    """Trained-policy playback. Mirror of ``simulo.core.player.Player``."""
+
+    def play(
+        self,
+        num_episodes: Optional[int] = ...,
+        num_steps: Optional[int] = ...,
+        real_time: bool = ...,
+        video_path: Optional[str] = ...,
+        video_length: int = ...,
+        deterministic: bool = ...,
+    ) -> Dict[str, Any]: ...
+    def load(self, path: str) -> None: ...

simulo/interfaces/runtime/policy.py

@@ -0,0 +1,16 @@
+"""``PolicyProtocol`` — structural mirror of ``simulo.core.policy.Policy`` (Part A)."""
+
+from typing import Optional, Protocol, runtime_checkable
+
+from simulo.interfaces.runtime.tensors import TensorLike
+
+
+@runtime_checkable
+class PolicyProtocol(Protocol):
+    """obs -> action callable. Mirror of ``simulo.core.policy.Policy``."""
+
+    @property
+    def input_dim(self) -> Optional[int]: ...
+    @property
+    def output_dim(self) -> Optional[int]: ...
+    def __call__(self, observation: TensorLike) -> TensorLike: ...

simulo/interfaces/runtime/scenario.py

@@ -0,0 +1,13 @@
+"""``ScenarioProtocol`` — structural mirror of ``simulo.scenario.Scenario`` (Part A)."""
+
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ScenarioProtocol(Protocol):
+    """Interactive sim lifecycle. Mirror of ``simulo.scenario.Scenario``."""
+
+    def build(self, scene: Any) -> None: ...
+    def on_start(self) -> None: ...
+    def on_step(self) -> None: ...
+    def on_shutdown(self) -> None: ...

simulo/interfaces/runtime/task.py

@@ -0,0 +1,21 @@
+"""``TaskProtocol`` — structural mirror of ``simulo.core.task.Task`` (Part A)."""
+
+from typing import Any, Protocol, Tuple, runtime_checkable
+
+from simulo.interfaces.runtime.tensors import TensorLike
+
+
+@runtime_checkable
+class TaskProtocol(Protocol):
+    """RL task contract — structural mirror of ``simulo.core.task.Task``."""
+
+    observation_dim: int
+    action_dim: int
+
+    def build(self, scene: Any) -> None: ...
+    def on_start(self, env: Any) -> None: ...
+    def get_observations(self) -> TensorLike: ...
+    def get_rewards(self) -> TensorLike: ...
+    def get_dones(self) -> Tuple[TensorLike, TensorLike]: ...
+    def apply_actions(self, actions: TensorLike) -> None: ...
+    def reset_idx(self, env_ids: TensorLike) -> None: ...

simulo/interfaces/runtime/tensors.py

@@ -0,0 +1,12 @@
+"""Tensor-library-agnostic alias for the runtime contract (Part A).
+
+The runtime Protocols describe tensor in/out method shapes without binding to
+any concrete tensor library. We do NOT import ``torch`` — not even under
+``TYPE_CHECKING`` — keeping the package importable with no torch installed AND
+mypy free of torch stubs. A concrete ``torch.Tensor`` is assignable to/from
+``Any``, so structural conformance of any real implementation still holds.
+"""
+
+from typing import Any
+
+TensorLike = Any

simulo/interfaces/runtime/trainer.py

@@ -0,0 +1,37 @@
+"""``TrainerProtocol`` — structural mirror of ``simulo.core.trainer.Trainer`` (Part A).
+
+Also home of the narrower ``PolicyExporterProtocol``: policy export is an
+*optional capability*, deliberately NOT a ``TrainerProtocol`` member. A Protocol
+binds ALL implementations, and the Trainer contract must not promise what only
+some trainers deliver — ``export_policy`` requires a deterministic, standalone
+exportable action head, which the base ``simulo.core.trainer.Trainer`` (a
+user-extensible ABC) does not guarantee. Implementations that CAN export (today:
+``simulo.core.trainer.RLTrainer``) declare the capability protocol separately;
+consumers feature-detect with ``isinstance(trainer, PolicyExporterProtocol)``.
+"""
+
+from typing import Any, Dict, Optional, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class TrainerProtocol(Protocol):
+    """Training orchestration. Mirror of ``simulo.core.trainer.Trainer``."""
+
+    def train(self, max_iterations: int) -> Dict[str, Any]: ...
+    def evaluate(self, checkpoint: Optional[str] = ..., num_episodes: int = ...) -> Dict[str, Any]: ...
+    def save(self, path: str) -> None: ...
+    def load(self, path: str) -> None: ...
+
+
+@runtime_checkable
+class PolicyExporterProtocol(Protocol):
+    """Optional capability: export the trained policy as a standalone artifact.
+
+    ``export_policy`` writes the policy's deterministic inference head to
+    ``path`` and returns the path actually written. Mirror of
+    ``simulo.core.trainer.RLTrainer.export_policy`` — see the module docstring
+    for why this is a separate protocol rather than a ``TrainerProtocol``
+    member.
+    """
+
+    def export_policy(self, path: str) -> str: ...

simulo_interfaces-0.1.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: simulo-interfaces
+Version: 0.1.0
+Summary: Implementation-free contract layer for the Simulo platform — torch-free runtime/sim Protocols and platform/workspace domain contracts. Importable with no torch/numpy/gymnasium/Isaac installed.
+Author-email: Simulo Team <team@simulo.ai>
+License: BSD-3-Clause
+Project-URL: Homepage, https://simulo.ai
+Project-URL: Source, https://github.com/simulo-org/simulo-platform
+Keywords: robotics,contracts,protocols,interfaces,simulo
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: black>=24.0; extra == "dev"
+Requires-Dist: isort>=5.13; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: pytest>=8.2; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.1; extra == "dev"
+Provides-Extra: release
+Requires-Dist: commitizen>=3.27; extra == "release"
+Requires-Dist: build>=1.2; extra == "release"
+Requires-Dist: twine>=5.1; extra == "release"
+
+# simulo-interfaces
+
+The **implementation-free contract layer** for the Simulo platform. A single,
+stable, torch-free, **zero-runtime-dependency** package that both Simulo SDK
+distributions depend on:
+
+- `simulo-backend` — the cloud GPU SDK (torch + IsaacLab + Isaac Sim).
+- `simulo` — the future thin local client (no heavy deps).
+
+Because both distributions share these contracts, `simulo-interfaces` is the one
+place the runtime Protocols and the platform/workspace domain model are defined.
+
+## What it is
+
+A pure-stdlib set of `typing.Protocol` contracts, frozen dataclasses, enums,
+`NewType` identifiers, and an exception hierarchy. Nothing here does any work —
+it only describes shapes.
+
+## What it is NOT
+
+It imports **none** of: `torch`, `numpy`, `gymnasium`, IsaacLab / Isaac Sim, AWS
+SDKs, HTTP clients, or database drivers. It performs **no** I/O, persistence, or
+computation. It is **not** a dumping ground (Contract Rule #12) — only contracts
+shared by more than one distribution belong here.
+
+The central invariant (Contract Rule #11): this package must import on a laptop
+with no torch/numpy/gymnasium/Isaac installed. Two tests enforce it:
+`tests/test_import_without_torch.py` (no heavy module enters `sys.modules`) and
+`tests/test_no_heavy_deps.py` (zero unconditional `Requires-Dist`).
+
+## Two parts
+
+### Part A — `simulo.interfaces.runtime`
+
+Tensor-library-agnostic structural mirrors of the `simulo.core` runtime surface.
+Tensors are typed as `TensorLike` (an alias for `Any`) so the contracts never
+bind to a concrete tensor library.
+
+- `TaskProtocol`, `PolicyProtocol`, `TrainerProtocol`, `PlayerProtocol`
+- `LearningEnvProtocol`, `ScenarioProtocol`
+- `ObservationComponentProtocol`, `RewardComponentProtocol`,
+  `TerminationConditionProtocol`
+- `PolicyExporterProtocol` — the narrow *optional* export capability
+  (`export_policy(path) -> str`). Deliberately not a `TrainerProtocol` member:
+  a Protocol binds all implementations, and only some trainers (today
+  `simulo.core.trainer.RLTrainer`) can deliver a deterministic standalone
+  policy export. Consumers feature-detect with `isinstance(trainer,
+  PolicyExporterProtocol)`.
+
+### Part B — `simulo.interfaces.platform`
+
+The platform/workspace domain contracts:
+
+- **Enums** — `JobStatus`, `ResumePolicy`, `ResourceKind`, `ArtifactKind`.
+- **Domain dataclasses** (frozen, slotted, keyword-only) — `Tag`, `Project`,
+  `Package`, `Resource`, `Job`, `Checkpoint`, `TrainedModel`.
+- **Cloud-execution Protocols** — `AppProtocol`, `JobFunctionProtocol`,
+  `RuntimeProtocol`, `AssetProtocol`, `VolumeProtocol`, `JobCallbackProtocol`,
+  `DebugSessionProtocol`, `ReplaySessionProtocol`, `VisualizationSessionProtocol`.
+
+## Public import surface
+
+```python
+import simulo.interfaces as si
+
+# exceptions + ids re-exported at the top level
+si.SimuloError, si.ContractViolationError, si.JobFailedError
+si.ProjectId, si.JobId, si.ResourceUri, si.Digest
+
+# Part A
+from simulo.interfaces.runtime import TaskProtocol, PolicyProtocol, LearningEnvProtocol
+
+# Part B
+from simulo.interfaces.platform import (
+    JobStatus, ResumePolicy, ResourceKind, ArtifactKind,
+    Project, Package, Job, Resource, Checkpoint, TrainedModel, Tag,
+    AppProtocol, RuntimeProtocol, AssetProtocol, VolumeProtocol,
+)
+```
+
+## Conformance model
+
+The contracts are `typing.Protocol`s — implementers conform **structurally**, no
+inheritance required.
+
+- **Static** — implementers (e.g. `simulo-backend`) are type-checked against
+  these Protocols by mypy. That static assertion is the primary conformance
+  gate and lives in the **implementer** package, not here.
+- **Runtime** — every Protocol is `@runtime_checkable`, so `isinstance(obj,
+  SomeProtocol)` provides a lightweight smoke check (presence of members only —
+  not signatures). This package's tests use that smoke form.
+- **Nominal (optional, opt-in per implementer)** — `simulo-backend`'s
+  `simulo.core` classes additionally *declare* the Part A Protocols as base
+  classes, so mypy drift-checks each implementation against its mirror at the
+  class-definition site. Nominal declaration never replaces the structural
+  contract — a third-party implementation that merely matches the signatures
+  still conforms.
+
+## Domain-model invariants
+
+- **Package ≠ Job** (Rule #5) — a `Package` is an immutable, content-addressed
+  source archive; a `Job` is one execution of a package and references it by id.
+- **Resource ≠ Package** (Rule #6) — a `Resource` is a read-only, versioned,
+  registry-resolved mount (robot / environment / dataset / …).
+- **Checkpoint ≠ TrainedModel** (Rule #8) — an intermediate training artifact is
+  a distinct type from the final, deployable model. Never collapse them.
+- **Project is the anchor** (Rule #7) — every other domain object hangs off a
+  `Project`.
+- **No packaged-skill type** (Rule #11) — there is deliberately no `Skill` /
+  `PackagedSkill` type here.
+
+## Stability policy
+
+- Enum **values** are a stable wire ABI: append-only, never renumber or rename.
+- Dataclass fields and Protocol method signatures follow the same
+  breaking-change discipline as the rest of the contract layer.
+- The package follows SemVer; additive changes (new optional field, new
+  Protocol, new enum member at the end) are minor/patch, removals/renames major.
+
+## Requirements
+
+- Python **>= 3.11** (uses `enum.StrEnum`). Tested on 3.11 and 3.12.
+- Standard library only — **zero** runtime dependencies.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+ruff check src
+black --check src tests
+isort --check-only src tests
+mypy src            # strict
+python -m build && twine check dist/*
+pytest
+```

simulo_interfaces-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+simulo/interfaces/__init__.py,sha256=4AcE1wwcD89GMuMjgbCERUjpRLdveJGd869qlZMthy8,1877
+simulo/interfaces/exceptions.py,sha256=UDK0k6SFf2uKqBGNCtOgdwGKqrR0EGX8JlT8k1-s7qM,1006
+simulo/interfaces/ids.py,sha256=du-ODsdz7twbv9q1xL_KPFPOegh2yeZUig1bZFm-tWs,946
+simulo/interfaces/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simulo/interfaces/platform/__init__.py,sha256=a5JoCCmvetwIo7xLO6XQ-80zdOuTbTScEqY88oHQZtY,3970
+simulo/interfaces/platform/app.py,sha256=1xO3ooZThI3H3mToFazCZyWZ2xMAzMPrxuLxnAz_wBk,1810
+simulo/interfaces/platform/asset.py,sha256=udUdC-p46XhDOmu939YLno95zozLCHPpsTQXI9Z4CMg,467
+simulo/interfaces/platform/callbacks.py,sha256=_RbzIvzEa2ZVn6KjYzOQ4z5EVV1gQorqSFcD-Hx_04Q,660
+simulo/interfaces/platform/debug.py,sha256=b-_4NylxAO4CkgAriv0dt2RBgwkEBxv1MibT8YmlYqY,804
+simulo/interfaces/platform/domain.py,sha256=VJaCf9bsoDAE9e0a0aXa1PHvaeNi3XNMplmNkzbF5GY,3286
+simulo/interfaces/platform/enums.py,sha256=cUPa-nVOHKpYco9QTeuzIYH_KChiUNWlWbtIN4t39PM,1239
+simulo/interfaces/platform/runs.py,sha256=gzzS-_p0WO3Odk2sgg2tbfbYmx4rahUVDBERBJbPJBk,5542
+simulo/interfaces/platform/runtime.py,sha256=eyVQVTVHa0y_l85FMWkPJuPMLfD34_tSjxEbSrHVydg,751
+simulo/interfaces/platform/submit.py,sha256=CFf4QTKa9Mp1JdzDt2wJsAHWsiqD7DMFEgekpEGe5sc,29298
+simulo/interfaces/platform/volume.py,sha256=rCi0C3-VKFiBfxmgNfNtZ9rLQ7CGtYmyC2r6jenHpM4,388
+simulo/interfaces/runtime/__init__.py,sha256=tv79QeafWvJ4EF-ew5QuzHLmYZaDyDjS2QiLqti8Et8,1952
+simulo/interfaces/runtime/anomaly.py,sha256=SFaZs83WVCsr5upIDHo4iGFXC0kaqJrFxGbRrrVFI-Y,9012
+simulo/interfaces/runtime/components.py,sha256=0XCZDk5em3K0TcrgxhqYvODUpVTtNeUOUpdC5uV8uts,1248
+simulo/interfaces/runtime/env.py,sha256=q_LnPwJr6DM7i0ifkzYFnqlYfcyrEfINN_SdXgti58Q,1136
+simulo/interfaces/runtime/player.py,sha256=1SldSTpbIV-l0c7nNg5BxKes5xV2NvLdOVuLy6BASEU,612
+simulo/interfaces/runtime/policy.py,sha256=DY1vNV3FrI0FLqJQwosvVStsGrJIjRPX-0lkIl9vJiI,523
+simulo/interfaces/runtime/scenario.py,sha256=Du0HHlmsg62wlCoVTSbTMbPRpvxeDNWZkPNx3ngKcZw,432
+simulo/interfaces/runtime/task.py,sha256=Jts29KtMJNvcvf4ciNSux-XVkVNP6DiDzJ77LW38giM,747
+simulo/interfaces/runtime/tensors.py,sha256=oA7wUpfIOXwT64rrF6W-TmRdJ800o_Y-auPn_VvL6E8,500
+simulo/interfaces/runtime/trainer.py,sha256=x0D6eKz3NPHTBrdMOmbbUvxvwGs9fRuzfYKQq736v2U,1683
+simulo_interfaces-0.1.0.dist-info/METADATA,sha256=lPwPsp_oBCGCg03i5QbN1DECQ4xy7a-6xLwKtaGe568,7028
+simulo_interfaces-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+simulo_interfaces-0.1.0.dist-info/top_level.txt,sha256=qud9mL24_iIiqb0ZMUSRitgwjDv_3zxgVqlWY45swJI,7
+simulo_interfaces-0.1.0.dist-info/RECORD,,

simulo_interfaces-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simulo_interfaces-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simulo