simulo 0.19.0__tar.gz → 0.20.0__tar.gz

{simulo-0.19.0/src/simulo.egg-info → simulo-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo
-Version: 0.19.0
+Version: 0.20.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.14,>=0.13.0
+Requires-Dist: simulo-interfaces<0.15,>=0.14.0
 Requires-Dist: mcap<2,>=1.3
 Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: usd-core<27,>=25.5
@@ -30,6 +30,8 @@ Requires-Dist: types-defusedxml==0.7.0.20260504; extra == "dev"
 Requires-Dist: pytest>=8.2; 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"

{simulo-0.19.0 → simulo-0.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulo"
-version = "0.19.0"
+version = "0.20.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.13.0,<0.14",
+    "simulo-interfaces>=0.14.0,<0.15",
     "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
@@ -77,6 +77,18 @@ dev = [
     "pytest>=8.2",
     "build>=1.2",
     "twine>=5.1",
+    # setuptools/wheel: `tests/test_create_wheel_packaging.py` builds a real wheel with
+    # `python -m build --wheel --no-isolation`, which reuses THIS interpreter's
+    # already-installed setuptools/wheel instead of resolving `[build-system].requires`
+    # into a fresh, network-fetched isolated build venv. Constraints mirror
+    # `[build-system].requires` above EXACTLY so the two can never drift apart.
+    # Without this, `pip install -e ".[dev]"` in a fresh Python 3.12 venv (which no
+    # longer bundles setuptools, unlike 3.11 and earlier) leaves that test failing with
+    # `Cannot import 'setuptools.build_meta'` — measured 2026-08-12. It passed in CI
+    # only because `.github/workflows/simulo-ci.yml` installs `pip setuptools wheel` as
+    # its own step, independently of this extra, which masked the gap.
+    "setuptools>=68",
+    "wheel",
 ]
 # `dev` carries build/twine but deliberately not commitizen; `release` below
 # adds commitizen for cutting version bumps without a second build/twine copy.

{simulo-0.19.0 → simulo-0.20.0}/src/simulo/_client/app.py

@@ -1025,35 +1025,14 @@ class App:
 
         Raises:
             ValueError: ``timeout`` is not ``None`` and is not a positive
-                integer (mirrors the worker's own
-                ``worker._effective_job_timeout_s`` guard — bare ``bool`` is
-                excluded even though it is an ``int`` subclass).
+                integer. ``True`` and ``False`` are not accepted as timeouts.
             TypeError: ``produces=`` or ``consumes=`` was passed. Outputs are
-                never declared on the decorator: callbacks
-                already imply their outputs, and a job body registers any
-                other produced file at execution time with
-                ``simulo.save_artifact(name, path)``. ``consumes=`` is
-                reserved for a future input declaration (chain jobs with
-                ``simulo run --from <job>[:latest|:best]`` today).
-
-                Note this guard is a deliberate BEHAVIOUR CHANGE, not the
-                formalisation of something that already failed. Neither kwarg
-                was ever *supported*, but until PR-B8 both were silently
-                *accepted*: ``**extra`` folded them straight into the job's
-                resource spec, so ``@app.job(produces=["report.html"])``
-                produced ``resources == {"produces": ["report.html"]}`` in
-                every published client — a misconfiguration the user could
-                not see, which is exactly why it is now rejected.
-
-                It is safe because the affected population is empty **by
-                evidence, not by construction**: no use of either kwarg exists
-                in this repo, its history, the demos, or the docs site. The
-                residual regression path is the worker, and it is worth naming
-                — an ALREADY-ARCHIVED package whose source contains
-                ``produces=`` now raises this ``TypeError`` at module import
-                on an upgraded runner, before discovery or execution reaches
-                anything else. Weigh that path first if the evidence above
-                ever stops holding.
+                not declared on the decorator. Callbacks such as
+                ``ResumableCheckpoint`` already declare their supported
+                outputs. Return small JSON values from the job, or use a named
+                volume for files another job needs. ``consumes=`` is reserved;
+                continue from a checkpoint with
+                ``simulo run --from <job>[:latest|:best]`` instead.
         """
         if timeout is not None and (isinstance(timeout, bool) or not isinstance(timeout, int) or timeout < 1):
             raise ValueError(
@@ -1062,10 +1041,10 @@ class App:
             )
         if "produces" in extra:
             raise TypeError(
-                "@app.job(produces=...) is not supported — job outputs are never declared on the "
-                "decorator. Callbacks such as simulo.callbacks.ResumableCheckpoint or DebugOnAnomaly "
-                "already declare the outputs they produce, and a job body registers any other produced "
-                "file at execution time with simulo.save_artifact(name, path). Remove produces=."
+                "@app.job(produces=...) is not supported. Callbacks such as "
+                "ResumableCheckpoint and DebugOnAnomaly already declare their supported outputs. "
+                "Return small JSON values from the job, or use a named Volume for files another "
+                "job needs. Remove produces=."
             )
         if "consumes" in extra:
             raise TypeError(

{simulo-0.19.0 → simulo-0.20.0}/src/simulo/_client/artifacts.py

@@ -38,30 +38,24 @@ def save_artifact(
     path: Union[str, bytes, "os.PathLike[str]", "os.PathLike[bytes]"],
     kind: Union[ArtifactKind, str] = ArtifactKind.FILE,
 ) -> bool:
-    """Register a file this job produced so the platform keeps it as an artifact.
+    """Register metadata for a file produced while this job is running.
 
-    Call it from a job body, after writing the file::
-
-        report = "/reports/summary.html"
-        write_report(report)
-        simulo.save_artifact("summary.html", report, kind="report")
-
-    The worker uploads every registered file once the job completes, and it
-    appears under the job's artifacts (``simulo artifacts <job>``) with the
-    ``name`` given here as its filename.
+    This validates the name, path, and kind, then records them in the running
+    job. The current managed platform does not upload general files registered
+    this way, so registration alone does not make the file available through
+    ``simulo artifacts`` after the job finishes. Return small JSON values from
+    the job, use a named :class:`simulo.Volume` for files another job needs, or
+    use the supported model and recording workflows for downloadable output.
 
     Args:
-        name: The artifact's logical filename — what the platform stores,
-            lists, and saves downloads under. A single safe filename, never a
-            path: separators, control characters, dots-only tokens, empty and
-            over-length names are rejected immediately with ``ValueError``
-            (:func:`~simulo.interfaces.platform.artifacts._validate_artifact_name`).
+        name: The registration's logical filename. It must be one safe
+            filename, never a path: separators, control characters, dots-only
+            tokens, empty values, and over-length names are rejected with
+            ``ValueError``.
         path: Filesystem path of the produced file. ``str``, ``bytes``, or any
             ``os.PathLike`` (a ``pathlib.Path`` works); bytes-ish values are
             ``os.fsdecode``-d, so a real non-UTF-8 filename registers fine.
-            Validated for usability (type, length, non-empty, no NUL) — *where*
-            it points is contained by the worker's uploader, which skips any
-            path outside the job's own artifact roots.
+            Validated for usability: type, length, non-empty, and no NUL.
         kind: What the output is — an
             :class:`~simulo.interfaces.platform.enums.ArtifactKind` or its wire
             string (e.g. ``"report"``, ``"dataset"``). Defaults to
@@ -70,27 +64,15 @@ def save_artifact(
 
     Returns:
         ``True`` when the registration was kept; ``False`` when it was dropped
-        because the run already registered ``simulo.outputs``'s
-        ``MAX_REGISTERED_OUTPUTS`` (1000) artifacts — a loop registering every
-        step's scratch file is a mistake, and the registry warns once on stderr
-        rather than failing the run over bookkeeping.
+        because the run already registered 1000 files. Register final output,
+        not a new scratch file on every simulation step.
 
     Raises:
         ValueError: ``name`` is not a safe single filename, ``path`` is not
             usable as a path, or ``kind`` is not a known artifact kind — all
-            surfaced at the call site, on the worker, before anything is
-            registered. **Every** argument problem arrives as ``ValueError``,
-            including the ones ``os.fsdecode`` would otherwise raise as
-            something else (see below) — one ``except ValueError`` around an
-            optional registration is a complete guard.
-        ModuleNotFoundError: ``simulo.outputs`` is installed but something IT
-            imports is missing (a broken backend install). Propagated as-is
-            rather than relabelled, because the missing module is not
-            ``simulo.outputs``.
-        RuntimeError: called where the ``simulo.outputs`` registry is not
-            installed (a submit-only environment forced into execution mode) —
-            never a supported state; at submit this function is not even
-            reachable, the name resolves to a Stub.
+            surfaced at the call site before anything is registered.
+        ModuleNotFoundError: The job runtime is missing a required dependency.
+        RuntimeError: Called outside a supported job execution context.
     """
     if isinstance(path, (bytes, os.PathLike)):
         # ``os.fsdecode`` maps a bytes / PathLike path to the exact ``str`` the