simulo 0.20.1__tar.gz → 0.22.0__tar.gz

{simulo-0.20.1 → simulo-0.22.0}/MANIFEST.in

@@ -1,4 +1,4 @@
-# Public-metadata discretion boundary (see release.yml Guard 5): the sdist is
+# Public-metadata discretion boundary (see release-pypi.yml Guard 5): the sdist is
 # PUBLIC on PyPI's "Download files" page just like the wheel, but setuptools'
 # sdist command auto-includes README.md and any top-level tests/ directory
 # regardless of the `readme = "PYPI.md"` pyproject setting. Exclude the

{simulo-0.20.1/src/simulo.egg-info → simulo-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo
-Version: 0.20.1
+Version: 0.22.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
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: simulo-interfaces<0.15,>=0.14.0
+Requires-Dist: simulo-interfaces<0.17,>=0.16.0
 Requires-Dist: mcap<2,>=1.3
 Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: usd-core<27,>=25.5

{simulo-0.20.1 → simulo-0.22.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulo"
-version = "0.20.1"
+version = "0.22.0"
 description = "Simulo SDK and CLI — define robotics simulation and training apps in Python and run them on the Simulo cloud."
 readme = "PYPI.md"
 requires-python = ">=3.11"
@@ -26,7 +26,7 @@ classifiers = [
 # mcap: used by `simulo recordings` to read back a downloaded recording and
 # verify it (message count) — MIT-licensed, deps only lz4+zstandard.
 dependencies = [
-    "simulo-interfaces>=0.14.0,<0.15",
+    "simulo-interfaces>=0.16.0,<0.17",
     "mcap>=1.3,<2",
     # Hardened XML parsing for URDF ingestion (USD Asset Catalogs, PR-12 fix
     # loop 2, security NIT): stdlib xml.etree.ElementTree relies on

{simulo-0.20.1 → simulo-0.22.0}/src/simulo/__init__.py

@@ -28,10 +28,10 @@ missed that way before the rule replaced it.
 
 Three kinds of name live on ``simulo``:
 
-* **Platform** names — ``App / Runtime / Volume / Asset / Artifact /
-  ArtifactKind / callbacks`` — are **real, eager** attributes bound below.
-  They are always torch-free (``Artifact`` is the ``simulo-interfaces``
-  contract dataclass, ``ArtifactKind`` its wire-stable ``StrEnum``, both
+* **Platform** names — ``App / Runtime / Volume / Asset / Output /
+  OutputKind / callbacks`` — are **real, eager** attributes bound below.
+  They are always torch-free (``Output`` is the ``simulo-interfaces``
+  contract dataclass, ``OutputKind`` its wire-stable ``StrEnum``, both
   re-exported).
 * **Contract vocabulary** — the shared error hierarchy (``SimuloError`` and its
   subclasses), the ``NewType`` identifier aliases (``JobId``, ``ProjectId``, …),
@@ -43,7 +43,7 @@ Three kinds of name live on ``simulo``:
   so this adds no import and no dependency. Errors and IDs are likewise
   stdlib-only (``NewType`` is the underlying ``str`` at runtime).
 * **Lazy, mode-aware** names — the learning names ``Task / Scene / Robot /
-  LearningEnv / RLTrainer / …`` plus the execution-time ``save_artifact`` and
+  LearningEnv / RLTrainer / …`` plus the execution-time ``save_output`` and
   ``run`` (the scenario execution loop) — are
   resolved through the PEP 562 ``__getattr__`` below, which delegates to the
   thin client's internal learning-name resolver. At submit (discovery mode) they resolve to
@@ -86,9 +86,13 @@ from simulo.interfaces import (
     ImportResolutionError,
     JobFailedError,
     JobId,
+    JobPublicId,
+    ModelPublicId,
     OrganizationId,
+    OutputPublicId,
     PackageId,
     ProjectId,
+    RecordingPublicId,
     ResourceId,
     ResourceNotFoundError,
     ResourceUri,
@@ -96,6 +100,10 @@ from simulo.interfaces import (
     SimuloError,
     TagId,
     TrainedModelId,
+    parse_job_public_id,
+    parse_model_public_id,
+    parse_output_public_id,
+    parse_recording_public_id,
 )
 
 # The authoring value types that the lazy resolver does NOT already carry.
@@ -144,7 +152,7 @@ from simulo.interfaces.authoring import (
     USDWorld,
     VisualMarkerBase,
 )
-from simulo.interfaces.platform import Artifact, ArtifactKind
+from simulo.interfaces.platform import Output, OutputKind
 
 # Public surface = eager platform exports (real attributes; ``__getattr__`` never
 # fires for these) + the lazily-resolved learning names. Kept a static literal so
@@ -152,8 +160,8 @@ from simulo.interfaces.platform import Artifact, ArtifactKind
 __all__ = [
     # platform (eager, real)
     "App",
-    "Artifact",
-    "ArtifactKind",
+    "Output",
+    "OutputKind",
     "Runtime",
     "Volume",
     "Asset",
@@ -170,6 +178,14 @@ __all__ = [
     "ProjectId",
     "PackageId",
     "JobId",
+    "JobPublicId",
+    "ModelPublicId",
+    "RecordingPublicId",
+    "OutputPublicId",
+    "parse_job_public_id",
+    "parse_model_public_id",
+    "parse_recording_public_id",
+    "parse_output_public_id",
     "ResourceId",
     "CheckpointId",
     "TrainedModelId",
@@ -206,7 +222,7 @@ __all__ = [
     "SphereMarker",
     "ArrowMarker",
     "PointMarker",
-    # lazy, mode-aware (the learning names + save_artifact)
+    # lazy, mode-aware (the learning names + save_output)
     "ActuatorGainsConfig",
     "Camera",
     "CameraSpawnConfig",
@@ -252,7 +268,7 @@ __all__ = [
     "Visual",
     "World",
     "run",
-    "save_artifact",
+    "save_output",
 ]
 
 
@@ -381,11 +397,9 @@ if TYPE_CHECKING:
     TerminationCondition = TerminationConditionProtocol
     # Annotation-position mirror name (see the rule above).
     Scene = SceneProtocol
-    # ``save_artifact`` aliases its real execution-mode implementation (a
-    # torch-free thin-client function), so ``simulo.save_artifact("summary",
+    # ``save_output`` aliases its real execution-mode implementation (a
+    # torch-free thin-client function), so ``simulo.save_output("summary",
     # path)`` type-checks with the precise signature instead of ``Any``.
-    from simulo._client.artifacts import save_artifact as save_artifact
-
     # ``run`` (the scenario execution loop) aliases its typing FACADE — a
     # plain FUNCTION facade, not a class one (there is no ``RunProtocol`` to
     # alias against; ``run`` is not a contract method). Without this, ``run``
@@ -400,6 +414,7 @@ if TYPE_CHECKING:
     # where drift against the real function is caught (a live, unmocked
     # signature comparison in ``simulo-backend``'s test suite, not mypy).
     from simulo._client.facades import run as run
+    from simulo._client.outputs import save_output as save_output
 
     # RELOCATED authoring value types (Plan C — Waves C1, C2, then C4's
     # ``RecordConfig``): the runtime object IS the real, dependency-free

{simulo-0.20.1 → simulo-0.22.0}/src/simulo/_client/_runner.py

@@ -25,9 +25,9 @@ import time
 from pathlib import Path
 from typing import Any, NoReturn, Optional
 
-from simulo.interfaces.ids import JobId
+from simulo.interfaces.ids import JobId, JobPublicId
 from simulo.interfaces.platform.enums import JobStatus
-from simulo.interfaces.platform.runs import TERMINAL_JOB_STATUSES
+from simulo.interfaces.platform.runs import JOB_SCOPE_MINE, TERMINAL_JOB_STATUSES
 
 #: Poll cadence for cloud ``.get()``. Module-level so tests can shrink it.
 _POLL_INTERVAL_S = 1.0
@@ -62,8 +62,8 @@ class JobHandle:
     """Handle to a submitted job — local-disk package, or a cloud job id.
 
     Returned by :meth:`JobFunction.spawn`. In cloud mode it carries the
-    server-assigned ``job_id`` plus enough context (``base_url`` / ``token``)
-    to poll it; ``execute_hint()`` still names the local package path
+    server-assigned machine ``job_id``, human-facing ``public_id``, and enough
+    context (``base_url`` / ``token``) to poll it; ``execute_hint()`` still names the local package path
     (preserved for debugging) but ``get()`` talks to the platform instead of
     raising.
     """
@@ -74,11 +74,13 @@ class JobHandle:
         package_path: Path,
         job_name: str,
         *,
+        public_id: Optional[JobPublicId] = None,
         cloud: bool = False,
         base_url: Optional[str] = None,
         token: Optional[str] = None,
     ) -> None:
         self._job_id = job_id
+        self._public_id = public_id
         self._package_path = package_path
         self._job_name = job_name
         self._cloud = cloud
@@ -90,6 +92,11 @@ class JobHandle:
         """Opaque id for this submission — server-assigned in cloud mode."""
         return self._job_id
 
+    @property
+    def public_id(self) -> Optional[JobPublicId]:
+        """Human-facing Job ID in cloud mode; ``None`` for local package-only submits."""
+        return self._public_id
+
     @property
     def package_path(self) -> Path:
         """Directory the package was written to (``<out>/<bundle_dir_name(package_id)>/``)."""
@@ -121,7 +128,9 @@ class JobHandle:
 
     def logs_hint(self) -> str:
         """The command that streams this job's logs (cloud mode)."""
-        return f"simulo logs {self._job_id} --follow"
+        if self._public_id is None:
+            return "simulo jobs"
+        return f"simulo logs {self._public_id} --follow"
 
     def get(self, timeout: Optional[float] = None) -> Any:
         """Return the job's result.
@@ -143,23 +152,29 @@ class JobHandle:
         client = JobsApiClient(self._base_url, token=self._token)
         deadline = None if timeout is None else time.monotonic() + timeout
         while True:
-            record = client.get_job(str(self._job_id))
+            record = client.get_job(str(self._job_id), scope=JOB_SCOPE_MINE)
             status = str(record.get("status"))
             if status in _TERMINAL_STATUS_STRINGS:
                 if status == _COMPLETED_STATUS:
-                    return client.get_result(str(self._job_id))
+                    return client.get_result(str(self._job_id), scope=JOB_SCOPE_MINE)
                 exit_code = record.get("exit_code")
                 raise JobFailedError(
-                    f"Job {self._job_name!r} ({self._job_id}) {status} (exit_code={exit_code}).\n"
+                    f"{self._display_name()} {status} (exit_code={exit_code}).\n"
                     f"  View its logs with:\n      {self.logs_hint()}"
                 )
             if deadline is not None and time.monotonic() >= deadline:
                 raise JobTimeoutError(
-                    f"Job {self._job_name!r} ({self._job_id}) did not reach a terminal status within "
+                    f"{self._display_name()} did not reach a terminal status within "
                     f"{timeout}s (still {status!r}). Check it with:\n      {self.logs_hint()}"
                 )
             time.sleep(_POLL_INTERVAL_S)
 
+    def _display_name(self) -> str:
+        """A user-facing label that never falls back to the machine UUID."""
+        if self._public_id is None:
+            return f"Job {self._job_name!r}"
+        return f"Job {self._job_name!r} ({self._public_id})"
+
     def _raise_local_disk_unavailable(self) -> NoReturn:
         raise JobResultUnavailable(
             f"No result is available locally for job {self._job_name!r}: submitting writes the "

{simulo-0.20.1 → simulo-0.22.0}/src/simulo/_client/app.py

@@ -38,7 +38,7 @@ from typing import TYPE_CHECKING, Any, Callable, Iterator, Mapping, Optional, Se
 from simulo._client import config, credentials, registry
 from simulo._client._runner import JobFailedError, JobHandle, JobResultUnavailable
 from simulo._client.runtime import DEFAULT_RUNTIME
-from simulo.interfaces.ids import JobId
+from simulo.interfaces.ids import JobId, parse_job_public_id
 from simulo.interfaces.platform import JobCallbackProtocol
 from simulo.interfaces.platform.app import Mount
 from simulo.interfaces.platform.enums import ResumePolicy
@@ -379,9 +379,8 @@ def _spawn_cloud(
     the identical rule: the seed reference is a SUBMIT-time job property,
     never a package property — it rides the job-create call only, verbatim
     (the control plane resolves prefixes and ``:best``/``:latest``). When the
-    server honors it, the RESOLVED provenance is announced on stderr (the
-    full source-job UUID — the confirmation that a typed prefix resolved to
-    the job the user meant); when an older server ignores it, ``create_job``
+    server honors it, the resolved provenance is announced on stderr without
+    exposing its machine UUID; when an older server ignores it, ``create_job``
     raises rather than let a fresh run masquerade as a seeded one.
 
     ``skip_preflight`` (``simulo run --skip-preflight``) bypasses the
@@ -420,7 +419,7 @@ def _spawn_cloud(
     from simulo._client.asset_pins import DEFAULT_ASSET_RUNTIME, collect_asset_refs, resolve_and_pin_assets
     from simulo._client.packaging import MANIFEST_FILENAME, ensure_tar
     from simulo._client.preflight_api import PreflightApiClient
-    from simulo._client.submit_api import SubmitApiClient
+    from simulo._client.submit_api import SubmitApiClient, SubmitApiError
     from simulo.interfaces.platform.manifest import Manifest
 
     manifest_text = (package_path / MANIFEST_FILENAME).read_text(encoding="utf-8")
@@ -500,17 +499,41 @@ def _spawn_cloud(
         app_name=app_name,
     )
 
+    raw_public_id = record.get("public_id")
+    try:
+        if not isinstance(raw_public_id, str):
+            raise TypeError("public_id is not a string")
+        public_id = parse_job_public_id(raw_public_id)
+    except (TypeError, ValueError):
+        # A current public cloud response must carry the human-facing Job ID.
+        # The machine UUID is intentionally not used as display fallback: the
+        # job may already have been created, so give a neutral recovery path.
+        raise SubmitApiError(
+            "The platform created the job but did not return a usable Job ID. "
+            "Run `simulo jobs` to find the submission before retrying."
+        ) from None
+
     if seed_from is not None:
         # create_job has already guaranteed the seed dict is present (the
         # loud-degradation guard) — this line is the human confirmation that
-        # the ref (possibly a prefix) resolved to the intended source job.
+        # the ref resolved to the intended source job. Seed provenance still
+        # carries machine UUIDs only, so keep this confirmation neutral rather
+        # than leaking a UUID while that response contract catches up.
         seed = record.get("seed") or {}
         print(
-            f"Continuing from job {seed.get('job_id')} ({seed.get('name')}, {seed.get('kind')} checkpoint)",
+            f"Continuing from selected job ({seed.get('name')}, {seed.get('kind')} checkpoint)",
             file=sys.stderr,
         )
 
-    return JobHandle(JobId(str(record["job_id"])), package_path, job_name, cloud=True, base_url=base_url, token=token)
+    return JobHandle(
+        JobId(str(record["job_id"])),
+        package_path,
+        job_name,
+        public_id=public_id,
+        cloud=True,
+        base_url=base_url,
+        token=token,
+    )
 
 
 class JobFunction:

{simulo-0.20.1 → simulo-0.22.0}/src/simulo/_client/cancel_api.py

@@ -97,8 +97,8 @@ class CancelApiClient:
             unavailable_hint=_UNAVAILABLE_HINT,
         )
         if not isinstance(payload, dict):
-            raise CancelApiError(f"Malformed cancel response for job {job_id!r}: expected a JSON object.")
+            raise CancelApiError("Malformed cancel response: expected a JSON object.")
         missing = [field for field in _REQUIRED_FIELDS if field not in payload]
         if missing:
-            raise CancelApiError(f"Malformed cancel response for job {job_id!r}: missing field(s) {missing}.")
+            raise CancelApiError(f"Malformed cancel response: missing field(s) {missing}.")
         return payload