simulo 0.26.0__py3-none-any.whl

simulo/callbacks.py

@@ -0,0 +1,274 @@
+"""Job lifecycle callbacks (``simulo.callbacks``).
+
+Each callback is a structural ``JobCallbackProtocol`` implementation. In the thin
+client the lifecycle hooks are intentionally no-ops — a callback DECLARES intent
+and serialises its configuration into the package manifest via
+:meth:`manifest_entry`; the platform honors it at execution. Today the backend
+runner honors ``ResumableCheckpoint`` (it exports the ``SIMULO_CHECKPOINT_*`` /
+``SIMULO_RESUME`` execution envelope that ``RLTrainer.train`` picks up for
+periodic, resumable checkpointing) and ``DebugOnAnomaly`` (it exports the
+``SIMULO_ANOMALY_DEBUG`` / ``SIMULO_ANOMALY_DEBUG_DIR`` execution envelope that
+``RLTrainer`` reads when constructed without an explicit ``debug_on_anomaly``);
+``CommitVolume`` is still recorded-only, resolved by the cloud worker in a
+follow-up.
+
+``DebugOnAnomaly`` here shares one field vocabulary with the runtime config
+:class:`simulo.interfaces.runtime.DebugOnAnomaly` that ``RLTrainer`` consumes;
+:meth:`DebugOnAnomaly.to_runtime_config` and
+:meth:`DebugOnAnomaly.from_manifest_config` are the explicit
+declaration → execution mapping. ``from_manifest_config`` delegates to the
+contract's own :meth:`simulo.interfaces.runtime.DebugOnAnomaly.from_config`
+classmethod rather than re-implementing the config → dataclass mapping.
+Torch-free by construction: this module imports only the (torch-free)
+``simulo-interfaces`` contract, never ``simulo-backend``.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import TYPE_CHECKING, Any, Mapping, Optional, Sequence
+
+from simulo.interfaces.runtime.anomaly import DebugOnAnomaly as _RuntimeDebugOnAnomaly
+
+if TYPE_CHECKING:
+    from simulo._client.volume import Volume
+
+
+class _CallbackBase:
+    """Shared no-op lifecycle hooks + manifest serialisation for callbacks."""
+
+    def on_job_start(self, job_id: str) -> None:  # noqa: D401 - no-op
+        return None
+
+    def on_checkpoint(self, checkpoint_uri: str, step: int) -> None:
+        return None
+
+    def on_anomaly(self, detail: str) -> None:
+        return None
+
+    def on_job_end(self, job_id: str, status: str) -> None:
+        return None
+
+    def manifest_entry(self) -> dict[str, Any]:
+        """Serialise this callback for the package manifest.
+
+        Returns ``{"type": "<ClassName>", "config": {...}}`` — the shape the
+        backend runner reads to reconstruct the execution envelope. The config
+        dict is JSON-serialisable by construction (plain ints/floats/bools/strs
+        or ``None``).
+        """
+        return {"type": type(self).__name__, "config": self._manifest_config()}
+
+    def _manifest_config(self) -> dict[str, Any]:
+        """Per-class configuration payload; subclasses override."""
+        return {}
+
+
+class ResumableCheckpoint(_CallbackBase):
+    """Declare periodic, resumable checkpointing for a job.
+
+    ``every`` is the checkpoint cadence in trainer iterations (the platform
+    picks a default when ``None``); ``keep_last`` additionally keeps the last N
+    numbered ``iter_<n>.pt`` copies beside ``latest.pt``.
+
+    Raises:
+        ValueError: if ``every`` or ``keep_last`` are provided and < 1 (caught at
+            authoring time, before packaging, so the error appears on the author's
+            machine rather than on the remote worker).
+    """
+
+    def __init__(self, *, every: Optional[int] = None, keep_last: Optional[int] = None) -> None:
+        if every is not None and every < 1:
+            raise ValueError(f"ResumableCheckpoint.every must be >= 1, got {every!r}.")
+        if keep_last is not None and keep_last < 1:
+            raise ValueError(f"ResumableCheckpoint.keep_last must be >= 1, got {keep_last!r}.")
+        self.every = every
+        self.keep_last = keep_last
+
+    def _manifest_config(self) -> dict[str, Any]:
+        return {"every": self.every, "keep_last": self.keep_last}
+
+
+class CommitVolume(_CallbackBase):
+    """Commit a volume's contents at checkpoint / job-end boundaries.
+
+    Attach to a job whose body writes into ``volume`` to make those writes
+    durable at well-defined points instead of only at process exit.
+
+    Args:
+        volume: The :class:`simulo.Volume` to commit.
+        commit_on_checkpoint: Also commit every time the job checkpoints.
+        commit_on_end: Commit when the job ends (success or failure).
+
+    Execution resolution: recorded-only today — the declaration rides the
+    package manifest; the cloud worker honors it in a follow-up.
+    """
+
+    def __init__(self, volume: "Volume", *, commit_on_checkpoint: bool = True, commit_on_end: bool = True) -> None:
+        self.volume = volume
+        self.commit_on_checkpoint = commit_on_checkpoint
+        self.commit_on_end = commit_on_end
+
+    def _manifest_config(self) -> dict[str, Any]:
+        return {
+            "volume": self.volume.name,
+            "commit_on_checkpoint": self.commit_on_checkpoint,
+            "commit_on_end": self.commit_on_end,
+        }
+
+
+class DebugOnAnomaly(_CallbackBase):
+    """Declare anomaly detection + MCAP debug-session capture for a job.
+
+    Mirrors the runtime config :class:`simulo.interfaces.runtime.DebugOnAnomaly`
+    field-for-field — same names, same defaults, same bounds validation (the
+    runtime config IS the validator, so an invalid declaration raises
+    ``ValueError`` on the author's machine, before packaging). See that class
+    for the full field/signal semantics; in brief, each anomaly kind maps to a
+    distinct failure mode rather than a single threshold:
+
+    * non-finite loss (``check_losses``) and reward collapse
+      (``check_reward_collapse`` with ``collapse_drop_fraction`` /
+      ``collapse_patience`` / ``collapse_baseline_floor``) at trainer chunk
+      boundaries;
+    * non-finite rewards, and non-finite or out-of-envelope
+      (``observation_limit``) observations, at env steps
+      (``check_observations``, every ``check_every_n_steps``).
+
+    On detection, a bounded MCAP debug session (``window_steps`` of pre-anomaly
+    evidence for ``env_indices``, at most ``max_captures`` files) is captured.
+
+    ``video="<camera name>"`` additionally buffers that camera's frames for
+    the first watched env and writes them into the same debug MCAP
+    (``/debug/window/video`` + a ``foxglove.CompressedVideo`` sibling) so the
+    capture shows what the sim *looked like* before the anomaly. Two honest
+    costs, documented on the runtime config's docstring in full: the camera
+    forces the render pipeline on during training (the env must enable
+    cameras), and the frame ring buffer holds up to ``window_steps`` raw RGB
+    frames in host memory (``window_steps x H x W x 3`` bytes).
+
+    The one deliberate field difference from the runtime config: ``output_dir``
+    is NOT declarable. Where debug outputs land is decided by the execution
+    environment (exactly like checkpoint directories) and supplied at
+    resolution time via :meth:`to_runtime_config` / :meth:`from_manifest_config`.
+
+    Execution resolution: honored by the backend runner. When the selected job
+    declares this callback, the runner exports the ``SIMULO_ANOMALY_DEBUG`` /
+    ``SIMULO_ANOMALY_DEBUG_DIR`` execution envelope before the job runs, and an
+    ``RLTrainer`` constructed without an explicit ``debug_on_anomaly`` argument
+    arms its anomaly monitor from it — declaring the callback is enough; no
+    hand-wiring in the job body. Precedence, strongest first: an explicit
+    ``RLTrainer(debug_on_anomaly=...)`` argument (including an explicit
+    ``enabled=False``) > an operator ``--env`` override of the envelope > a
+    package ``runtime_env``-supplied ``SIMULO_ANOMALY_DEBUG`` (the config key
+    is user-tunable; ``SIMULO_ANOMALY_DEBUG_DIR`` is runner-reserved, so a
+    package can never choose where captures land) > this declaration >
+    nothing. The mapping helpers remain the explicit
+    declaration → execution mapping for custom executors:
+    ``RLTrainer(..., debug_on_anomaly=cb.to_runtime_config())``, or from a
+    parsed manifest entry,
+    ``DebugOnAnomaly.from_manifest_config(entry["config"], output_dir=...)``.
+
+    Raises:
+        ValueError: on out-of-bounds configuration (caught at authoring time,
+            before packaging, so the error appears on the author's machine
+            rather than on the remote worker).
+    """
+
+    def __init__(
+        self,
+        *,
+        enabled: bool = True,
+        window_steps: int = 256,
+        env_indices: Sequence[int] = (0,),
+        check_observations: bool = True,
+        observation_limit: Optional[float] = 1e6,
+        check_every_n_steps: int = 1,
+        video: Optional[str] = None,
+        check_losses: bool = True,
+        check_reward_collapse: bool = True,
+        collapse_drop_fraction: float = 0.5,
+        collapse_patience: int = 2,
+        collapse_baseline_floor: float = 1e-6,
+        max_captures: int = 1,
+    ) -> None:
+        # Construct the runtime config immediately: single source of validation
+        # + normalisation (env_indices -> tuple), identical to what the trainer
+        # enforces. A drift in defaults is locked out by tests.
+        self._runtime_config = _RuntimeDebugOnAnomaly(
+            enabled=enabled,
+            window_steps=window_steps,
+            env_indices=env_indices,
+            check_observations=check_observations,
+            observation_limit=observation_limit,
+            check_every_n_steps=check_every_n_steps,
+            video=video,
+            check_losses=check_losses,
+            check_reward_collapse=check_reward_collapse,
+            collapse_drop_fraction=collapse_drop_fraction,
+            collapse_patience=collapse_patience,
+            collapse_baseline_floor=collapse_baseline_floor,
+            max_captures=max_captures,
+        )
+        cfg = self._runtime_config
+        self.enabled = cfg.enabled
+        self.window_steps = cfg.window_steps
+        self.env_indices: tuple[int, ...] = tuple(cfg.env_indices)
+        self.check_observations = cfg.check_observations
+        self.observation_limit = cfg.observation_limit
+        self.check_every_n_steps = cfg.check_every_n_steps
+        self.video = cfg.video
+        self.check_losses = cfg.check_losses
+        self.check_reward_collapse = cfg.check_reward_collapse
+        self.collapse_drop_fraction = cfg.collapse_drop_fraction
+        self.collapse_patience = cfg.collapse_patience
+        self.collapse_baseline_floor = cfg.collapse_baseline_floor
+        self.max_captures = cfg.max_captures
+
+    def _manifest_config(self) -> dict[str, Any]:
+        return {
+            "enabled": self.enabled,
+            "window_steps": self.window_steps,
+            "env_indices": list(self.env_indices),
+            "check_observations": self.check_observations,
+            "observation_limit": self.observation_limit,
+            "check_every_n_steps": self.check_every_n_steps,
+            "video": self.video,
+            "check_losses": self.check_losses,
+            "check_reward_collapse": self.check_reward_collapse,
+            "collapse_drop_fraction": self.collapse_drop_fraction,
+            "collapse_patience": self.collapse_patience,
+            "collapse_baseline_floor": self.collapse_baseline_floor,
+            "max_captures": self.max_captures,
+        }
+
+    def to_runtime_config(self, *, output_dir: Optional[str] = None) -> _RuntimeDebugOnAnomaly:
+        """The :class:`simulo.interfaces.runtime.DebugOnAnomaly` this declaration maps onto.
+
+        ``output_dir`` is the executor-supplied output directory; ``None``
+        keeps the runtime config's default (``runs/debug``).
+        """
+        if output_dir is None:
+            return self._runtime_config
+        return dataclasses.replace(self._runtime_config, output_dir=output_dir)
+
+    @classmethod
+    def from_manifest_config(
+        cls, config: Mapping[str, Any], *, output_dir: Optional[str] = None
+    ) -> _RuntimeDebugOnAnomaly:
+        """Construct the runtime config from a manifest ``config`` payload (executor side).
+
+        Delegates to the contract's own
+        :meth:`simulo.interfaces.runtime.DebugOnAnomaly.from_config` (the
+        canonical declaration → execution mapping, added alongside it). Reads
+        exactly the keys :meth:`_manifest_config` writes; unknown keys are
+        ignored (forward compatibility with newer clients) and value
+        validation is the runtime config's own ``__post_init__``. A
+        manifest-supplied ``output_dir`` is ignored too — the output
+        directory is executor-owned and passed only via the ``output_dir``
+        keyword.
+        """
+        return _RuntimeDebugOnAnomaly.from_config(config, output_dir=output_dir)
+
+
+__all__ = ["ResumableCheckpoint", "CommitVolume", "DebugOnAnomaly"]

simulo-0.26.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: simulo
+Version: 0.26.0
+Summary: Simulo SDK and CLI — define robotics simulation and training apps in Python and run them on the Simulo cloud.
+Author-email: Simulo Team <team@simulo.ai>
+License: BSD-3-Clause
+Project-URL: Homepage, https://simulo.ai
+Keywords: robotics,simulation,reinforcement-learning,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
+Requires-Dist: simulo-interfaces<0.20,>=0.19.0
+Requires-Dist: mcap<2,>=1.3
+Requires-Dist: defusedxml>=0.7.1
+Requires-Dist: usd-core<27,>=26.5
+Provides-Extra: assets
+Requires-Dist: usd-core<27,>=26.5; extra == "assets"
+Provides-Extra: dev
+Requires-Dist: black==26.5.1; extra == "dev"
+Requires-Dist: isort==8.0.1; extra == "dev"
+Requires-Dist: ruff==0.15.21; extra == "dev"
+Requires-Dist: mypy==2.3.0; extra == "dev"
+Requires-Dist: types-defusedxml==0.7.0.20260504; extra == "dev"
+Requires-Dist: pytest>=8.2; extra == "dev"
+Requires-Dist: pytest-timeout==2.4.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.1; extra == "dev"
+Requires-Dist: setuptools>=68; extra == "dev"
+Requires-Dist: wheel; 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
+
+The Simulo SDK and CLI — define robotics simulation and training apps in Python,
+submit them to the Simulo cloud, monitor jobs, and retrieve trained models.
+
+Simulo is a cloud-first robotics simulation and training platform. Write your app
+against a small, stable Python API; Simulo handles running it.
+
+## Install
+
+```bash
+pip install simulo
+```
+
+Requires Python 3.11+.
+
+## Quickstart
+
+The fastest way to start: scaffold a runnable app.
+
+```bash
+simulo create mybot
+# Created training app in mybot/ (app.py + .simuloignore).
+cd mybot
+```
+
+`--type` picks the starter shape (default `training`): `training` (a single
+training job), `inference` (train → evaluate → rollout, self-contained), or
+`scenario` (a scripted scene, no learning). No network call and no login
+required — `simulo create` only writes files to your local folder. Edit
+`app.py` for your own robot and task, then see "Log in and submit" below to
+run it.
+
+To download a curated collection of runnable projects, use `simulo install samples`.
+It creates `./simulo-samples` as a normal Git clone, so `cd simulo-samples` and
+`cat README.md` open the sample index.
+
+### Or write an app by hand
+
+```python
+# app.py
+import simulo
+
+app = simulo.App("hello")
+
+
+@app.job(timeout=5 * 60)
+def hello(name: str = "world", repeat: int = 3) -> dict:
+    for i in range(repeat):
+        print(f"[hello] {i + 1}/{repeat}: hello, {name}!")
+    return {"greeting": f"hello, {name}", "repeat": repeat}
+
+
+@app.entrypoint
+def main(name: str = "world", repeat: int = 3) -> None:
+    handle = hello.spawn(name=name, repeat=repeat)
+    print(f"Submitted job: {handle.job_name}")
+```
+
+## Log in and submit to the cloud
+
+```bash
+simulo login
+simulo run app.py --name robot --repeat 5
+```
+
+Without logging in, `simulo run` packages the app locally without submitting it.
+
+Every cloud submit is fresh — running the same command twice trains twice, never a silent
+no-op. To continue training from an earlier job's checkpoint instead, pass
+`--from <job-ref>[:best|:latest]`. `<job-ref>` is a full job id, matched by exact equality;
+an unambiguous prefix (`>=4` characters, Git-style) works too, but only for the legacy UUID
+form some jobs from before friendly identifiers still carry.
+
+## Monitor jobs and retrieve results
+
+```bash
+simulo jobs                      # your jobs and their statuses
+simulo logs --follow             # stream the latest job's logs live
+simulo result                    # the completed job's result JSON
+simulo models                    # list / download trained checkpoints (sha256-verified)
+simulo recordings                # download MCAP flight recordings
+simulo view                      # watch the live 3D scene (jobs submitted with --viewstream)
+simulo cancel                    # cancel a queued or running job
+```
+
+Commands that take a job id default to the latest job, announcing what they
+resolved to on stderr.
+
+Learn more at [simulo.ai](https://simulo.ai).

simulo-0.26.0.dist-info/RECORD

@@ -0,0 +1,55 @@
+simulo/__init__.py,sha256=_VyDCuGWSWY9GVA02JUXOfW9jYUj-TFAhYb3f_0oLxU,18753
+simulo/callbacks.py,sha256=NOY2jW0eyTpQmqLOk7DtyZnCTA3SjLzzyuWZ-9i3MgU,12754
+simulo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simulo/_client/__init__.py,sha256=1gyCv0KXJYydbwbfG2pGptrpoH7gKApqXkWTzn47bec,288
+simulo/_client/_entrypoint.py,sha256=8jUo4nz1ckYBklby4hlPI2GOcVCc4eJp0fw-LhiRBAI,14191
+simulo/_client/_mounts.py,sha256=mWxcnP1Sj5Tlpa282F08OhLAEI82tE7ZDbdyiGNTTDo,833
+simulo/_client/_runner.py,sha256=O8eumXDmMkNhmcarPFjG4G1kL_Q_yxdBMHCBV2q4X2c,7676
+simulo/_client/_secure_downloads.py,sha256=wnLyuDjv2lIZ-MFP56qFhls6IzXxBlxuvE4BOohKKKI,58711
+simulo/_client/app.py,sha256=OGxUXE_mPgAc7874poE4dbyiyPA4QlLIIHM_Rn916ds,63560
+simulo/_client/asset.py,sha256=gj2jl9eMXB4FEzm6855j2FwcZt3zJyWnoTB1wwccMn0,15481
+simulo/_client/asset_api.py,sha256=e-uN7Uf3y_7wxDt9DhYemo-mWcA0mLWaOVIhnK_JjRI,24056
+simulo/_client/asset_package.py,sha256=a_y332c9UNgV1BGtRoM_J2xo3GTb_f0Yyt3y2gecKEQ,50345
+simulo/_client/asset_pins.py,sha256=3YuW98OHHM9DRUYiVT1icJOx2CFKdGHaxrlVO4pfuQo,8622
+simulo/_client/builtin_aliases.py,sha256=Yv1-AeE5WsOE_NhkHnPW7-AjgutAvwtLGi5JogvOKv8,5711
+simulo/_client/bundle.py,sha256=26ovBnIpgfakl8TQSBneuNbh_vRNsRbVG5v0bnEBYd8,13294
+simulo/_client/cancel_api.py,sha256=cgf_OLAhNTa-WnW96t3ihq7lGBW9QAKecxzcZrjUX14,5145
+simulo/_client/cli.py,sha256=DR5EWuBVw8gVxpeeRfDYOkbI9C5E9MJQ5lagy3INVu0,429585
+simulo/_client/config.py,sha256=hPDkCXjwBz7VbwKl-Dt64xn6jdIZFBnHtf6cADrRb1Q,8469
+simulo/_client/credentials.py,sha256=yYnAvKz1ZN6V5PGSX52DVL3-lNLQnV8fv2cit333sro,9337
+simulo/_client/discovery.py,sha256=5jGlDceYUfyp4Cme8rclLJTnGAJLpmxtaPC3bZAu584,9164
+simulo/_client/export_api.py,sha256=I48Eskk42DRdXE4zxjvcmsfynuLVrlrKbOSD-DZ0gsc,9945
+simulo/_client/export_bundle.py,sha256=gZUEasrjW_c_uhxfr6HZZzPby5-jClvSwTF4Z9JP-4Y,14571
+simulo/_client/facades.py,sha256=_iYyDU_22DmkJy_wsqVdwDExcVFchN11LQ3z_BR1bFk,21366
+simulo/_client/http.py,sha256=6iRI29l_y73pzQae9PcLmKBQbkcaRfMjO18qzKu-DGI,20493
+simulo/_client/identity_api.py,sha256=kKVj5N7R7KQwzK2Urr22ki-yixRXbkxKnDh6Gb-IZEo,5571
+simulo/_client/install_samples.py,sha256=Obm3hDerCPGJqEFnHyoXGyjKZcPmHu6vkoJwmYrq940,10416
+simulo/_client/jobs_api.py,sha256=nhu8tsgXj3njFtTt-yDJBNy2yk_sljnw0r-gAkR9J7c,11336
+simulo/_client/learning.py,sha256=JbXx2hNcA-wHP2T79wHDJ6GLBceytVqsc26FcTqrFfg,18880
+simulo/_client/login.py,sha256=yex6B9TPg4LrVCwtOHswagUwB4leerO1TcAto08mDGE,13971
+simulo/_client/mode.py,sha256=WB-Dm3IpEauYQxE4NX3w6f4FPOj5t3GC2dHrNCakyl4,1205
+simulo/_client/outputs.py,sha256=slmw3aAakdPwr-rQsiHD43PgTyHjEOLWvRplN1jb9nw,6160
+simulo/_client/packaging.py,sha256=XZ8pjEMazEVpWktkJlbOxoyT9EhsdQ6My4X4fC74P-g,20895
+simulo/_client/preflight_api.py,sha256=-WcEBdrDllzUaYaxfFKZ_HYNofQVa0Yhk_-z3WfYf_o,8860
+simulo/_client/preflight_render.py,sha256=f4H2mzE2g7xIp-2fk5pVwQl034hKbzZMq4bEVIrlnlA,10284
+simulo/_client/registry.py,sha256=zf0ZQAX37_e5b9S61ulEE0NL6aVlhYFlPiVHJqwR_f8,4670
+simulo/_client/runtime.py,sha256=ABOrfmLQ6sNFviG4dqSSQuyy-pqHB_2Wpiu9CBaaCB8,8762
+simulo/_client/runtime_display.py,sha256=1dDOaesN9qKvqarN6AxInJCXN7wRxm_RQx_UXkXlins,4194
+simulo/_client/seed_ref.py,sha256=M1Mrvm-DPG5ehn9XVrt57JsNOvt0OGi89kBsH4wRVtI,3742
+simulo/_client/stub.py,sha256=jepEvY7Gwzpw0uQgBvSTvki7sMS2RxJddQv2ioHrBLY,1601
+simulo/_client/submit_api.py,sha256=YYLgfourlvFnqTwHoIJBGNsLF-_xH5jj29B3Ge8tRL8,53611
+simulo/_client/view_fragment.py,sha256=ahqQFLzJeNpMhz2hg0ex2O_qD0taWfHGgkljxyxiiHs,638
+simulo/_client/view_session_api.py,sha256=yMgTtyntmAy9orYFOCiFFZDbuK8V_kfgZGDFCheAShI,6398
+simulo/_client/volume.py,sha256=oYmk4mbp0Ys6ghWUqAG_ovlEERBGVM3-1n3MeS_NcnU,2763
+simulo/_client/templates/__init__.py,sha256=je_epSb6DI14y3AByACTGjxlE-a0IAwrgADdbAxOHYw,1199
+simulo/_client/templates/inference/app.py.tmpl,sha256=somjeBYQCN2SS-2UKnx0hA5gZGyMCuXtB8vayfxFc_w,13281
+simulo/_client/templates/inference/simuloignore.tmpl,sha256=vXAa_SxtK3EAlRueJ7iocTU9JotNnEFdtRvq0wGXQts,751
+simulo/_client/templates/scenario/app.py.tmpl,sha256=8VZSz6Jr_P209STv4KbSa1CxiQQlXH2-5lRVrOYK4Nc,3957
+simulo/_client/templates/scenario/simuloignore.tmpl,sha256=OOe3i2mKeq73-eFBRTsvr6tM-qSG-7yuVQFvKUbAp8A,621
+simulo/_client/templates/training/app.py.tmpl,sha256=y3R2KiVBMTFNd7uvBEkUgzFHa_OnPfK_6NfNo8AGULM,10109
+simulo/_client/templates/training/simuloignore.tmpl,sha256=p1SXAnsYrfoSMDqEjm2kc28eFgW2LL8udo5kEpyO6UM,725
+simulo-0.26.0.dist-info/METADATA,sha256=AvYklt7NNVyGB-BNwMIF1T7CGhrrG01URN4grbqTMT8,4582
+simulo-0.26.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+simulo-0.26.0.dist-info/entry_points.txt,sha256=h66ahOv6BFEPtaS8r4QU_C5wpTMLWr3xJYe6QQ8LLkQ,51
+simulo-0.26.0.dist-info/top_level.txt,sha256=qud9mL24_iIiqb0ZMUSRitgwjDv_3zxgVqlWY45swJI,7
+simulo-0.26.0.dist-info/RECORD,,

simulo-0.26.0.dist-info/WHEEL

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

simulo-0.26.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simulo = simulo._client.cli:main

simulo-0.26.0.dist-info/top_level.txt

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