simulo 0.31.0__tar.gz → 0.31.2__tar.gz

{simulo-0.31.0/src/simulo.egg-info → simulo-0.31.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo
-Version: 0.31.0
+Version: 0.31.2
 Summary: Python SDK and CLI for cloud-native robotics simulation, reinforcement learning, and robot policy training on managed GPUs.
 Author-email: Simulo Team <team@simulo.ai>
 License: BSD-3-Clause

{simulo-0.31.0 → simulo-0.31.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulo"
-version = "0.31.0"
+version = "0.31.2"
 description = "Python SDK and CLI for cloud-native robotics simulation, reinforcement learning, and robot policy training on managed GPUs."
 readme = "PYPI.md"
 requires-python = ">=3.11"

{simulo-0.31.0 → simulo-0.31.2}/src/simulo/_client/builtin_aliases.py

@@ -9,21 +9,12 @@ equivalent has been seeded — pointing the user at the ``simulo/robot/...`` idi
 Two pieces:
 
 * :data:`BUILTIN_ASSET_ALIASES` — the ``<builtin-name> -> <catalog-ref>`` table.
-  **PR-13 populated this table for real**, from a live GPU seeding run
-  (``scripts/seed-global-catalog.py``, run against a real control plane + a
-  real worker on the local 3090): every entry below is a builtin whose USD
-  closure localized AND whose real cloud validation (settle + actuation
-  probes) actually PASSED. A ``BUILTIN_ROBOT_CONFIGS`` name that isn't here
-  (``cartpole``, ``franka``, ``humanoid``, ``unitree_go2``, ``ur10`` as of
-  PR-13) genuinely has NOT been seeded — it failed real validation or could
-  not be localized into a self-contained package — so the scan below finds
-  nothing for it and NO notice is printed; that ``builtin://`` ref still
-  resolves through the legacy path. Do not add entries here by hand: a name
-  belongs in this table only once ``scripts/seed-global-catalog.py`` has
-  actually published + validated its ``simulo/robot/<name>`` catalog entry
-  (the script's own ``update_alias_table`` appends here, additively, keyed
-  on the SAME name it published under — see that script for the current
-  seed report), or the notice would send users to a ref that 404s.
+  Every entry was published by the catalog seeding script and passed real
+  validation. A builtin that is not here has not, so the scan below prints no
+  notice for it and its ``builtin://`` reference still resolves the old way.
+  Add entries only after a real publish and validation (the seeding script
+  appends them itself); otherwise the notice would send users to a catalog
+  reference that does not exist.
 
 * :func:`scan_source_for_builtin_aliases` — a textual scan of the packaged source
   files at submit, returning every ``(builtin_name, catalog_ref)`` pair whose
@@ -45,7 +36,9 @@ from typing import Dict, List, Tuple
 BUILTIN_ASSET_ALIASES: Dict[str, str] = {
     "anymal": "simulo/robot/anymal-c",
     "anymal_c": "simulo/robot/anymal-c",
+    "cartpole": "simulo/robot/cartpole",
     "h1": "simulo/robot/unitree-h1",
+    "humanoid": "simulo/robot/humanoid",
     "jetbot": "simulo/robot/jetbot",
     "pick_and_place": "simulo/robot/pick-and-place",
     "unitree_h1": "simulo/robot/unitree-h1",

{simulo-0.31.0 → simulo-0.31.2}/src/simulo/_client/cli.py

@@ -168,7 +168,7 @@ from simulo._client.asset_package import (
     slugify_name,
     validate_asset_name,
 )
-from simulo._client.asset_pins import collect_asset_refs
+from simulo._client.asset_pins import collect_asset_refs, resolve_and_pin_assets
 from simulo._client.builtin_aliases import format_builtin_deprecation_notice, scan_source_for_builtin_aliases
 from simulo._client.bundle import build_manifest
 from simulo._client.cancel_api import CancelApiClient, CancelApiHTTPError
@@ -673,6 +673,14 @@ def _resolve_client_context() -> tuple[str, Optional[str]]:
     return base_url, token
 
 
+def _client_with_fresh_token(client: JobsApiClient) -> JobsApiClient:
+    """Return a client with current stored credentials, preserving its target."""
+    creds = credentials.try_get_valid_credentials(base_url=client.base_url)
+    if creds is None:
+        return client
+    return JobsApiClient(client.base_url, token=str(creds["access_token"]))
+
+
 def _is_uuid_text(value: Any) -> bool:
     try:
         UUID(str(value))
@@ -1470,10 +1478,16 @@ def _follow_and_report(handle: JobHandle, app_path: str) -> int:
         job_ref = str(getattr(handle, "public_id", None) or handle.job_id)
         exit_code = _drain_logs(client, job_ref, follow=True, scope=JOB_SCOPE_MINE)
         if handle.job_type is JobType.PREVIEW:
+            client = _client_with_fresh_token(client)
             return _report_preview(client, job_ref, display_id, app_path, fallback_exit_code=exit_code)
         if exit_code == 0:
             if handle.job_type is JobType.TRAIN:
-                _print_training_next_steps(handle, app_path)
+                client = _client_with_fresh_token(client)
+                _print_training_next_steps(
+                    PoliciesApiClient(client.base_url, token=client._token),
+                    handle,
+                    app_path,
+                )
             elif handle.job_type is JobType.PLAY:
                 print(f"Next: simulo recordings {display_id}")
         return exit_code
@@ -1566,12 +1580,11 @@ def _checkpoint_iteration(handle: JobHandle, checkpoint_ref: str) -> Optional[in
     return None
 
 
-def _print_training_next_steps(handle: JobHandle, app_path: str) -> None:
+def _print_training_next_steps(client: PoliciesApiClient, handle: JobHandle, app_path: str) -> None:
     """Print the sealed policy's checkpoints and the three canonical next steps."""
-    assert handle.base_url is not None
     policy_id = str(policy_id_for_job(_handle_display_id(handle)))
     try:
-        record = PoliciesApiClient(handle.base_url, token=handle.token).get_policy(policy_id)
+        record = client.get_policy(policy_id)
     except http.HttpError:
         return
     rendered: list[str] = []
@@ -1693,8 +1706,8 @@ def _render_preflight_outcome(app_file: Path, outcome: PreflightOutcome) -> int:
 
 
 def _cmd_prepare(args: argparse.Namespace) -> int:
-    """``simulo prepare <app>`` — build the manifest and ask the platform
-    whether this app would submit cleanly, before uploading a single byte.
+    """``simulo prepare <app>`` — build the manifest, resolve its assets when
+    authenticated, and ask whether the app would submit cleanly before upload.
 
     Never uploads a package, never creates a job — safe to run as often as
     you like before ``simulo run``. It DOES import your app file to discover
@@ -1710,22 +1723,46 @@ def _cmd_prepare(args: argparse.Namespace) -> int:
     if not app_file.is_file():
         raise SystemExit(f"No such app file: {app_file}")
     project_root = app_file.parent
-    app = discover(app_file)
-    if not isinstance(app, App):
-        raise TypeError(f"Discovered object is not a simulo.App: {app!r}")
-    _validate_app_job_file(app, app_file)
-    # Builds the manifest only — no source tree copy, no tar, no upload. The
-    # #285 platform-pinned-package denylist (``build_manifest``'s own
-    # ``SystemExit``) still applies here exactly as it does at `simulo run`;
-    # it is a DIFFERENT, client-side-only mechanism from the preflight HTTP
-    # call below and must never be confused with a preflight finding (see
-    # the preflight API/rendering separation verified by the CLI tests).
-    manifest = build_manifest(app, app_file, project_root)
+    with capture_constructed_assets() as captured_assets:
+        app = discover(app_file)
+        if not isinstance(app, App):
+            raise TypeError(f"Discovered object is not a simulo.App: {app!r}")
+        _validate_app_job_file(app, app_file)
+        # Builds the manifest only — no source tree copy, no tar, no upload. The
+        # #285 platform-pinned-package denylist (``build_manifest``'s own
+        # ``SystemExit``) still applies here exactly as it does at `simulo run`;
+        # it is a DIFFERENT, client-side-only mechanism from the preflight HTTP
+        # call below and must never be confused with a preflight finding (see
+        # the preflight API/rendering separation verified by the CLI tests).
+        manifest = build_manifest(app, app_file, project_root, extra_assets=captured_assets)
     manifest_data = json.loads(manifest.to_json())
     asset_refs = collect_asset_refs(manifest_data)
-    base_url, token = _resolve_client_context()
+    try:
+        base_url, token = _resolve_client_context()
+    except credentials.TokenRefreshError as exc:
+        if not _caused_by(exc, http.HttpUnavailable):
+            raise
+        # Asset resolution and preflight are optional checks. Preserve a
+        # rejected refresh as a hard authentication error, while allowing a
+        # network-only refresh failure to use the saved target without sending
+        # the expired bearer.
+        stale_creds = credentials.load_credentials()
+        base_url, token = config.resolve_base_url(stale_creds), None
+    resolved_assets: Optional[list[dict[str, str]]] = [] if not asset_refs else None
+    if asset_refs:
+        if token is None:
+            print("Asset references were not checked.", file=sys.stderr)
+        else:
+            try:
+                resolved_assets = resolve_and_pin_assets(SubmitApiClient(base_url, token=token), asset_refs)
+            except http.HttpUnavailable:
+                print("Asset references were not checked.", file=sys.stderr)
+            except http.HttpHTTPError as exc:
+                if exc.status != 404 and not 500 <= exc.status <= 599:
+                    raise
+                print("Asset references were not checked.", file=sys.stderr)
     client = PreflightApiClient(base_url, token=token)
-    outcome = client.evaluate(manifest, assets=[] if not asset_refs else None)
+    outcome = client.evaluate(manifest, assets=resolved_assets)
     return _render_preflight_outcome(app_file, outcome)
 
 
@@ -2386,6 +2423,7 @@ def _wait_for_job(client: JobsApiClient, job_id: str, *, scope: str = JOB_SCOPE_
     """Poll until ``job_id`` exists — lets a user arm the tail BEFORE the job is created."""
     waiting_announced = False
     while True:
+        client = _client_with_fresh_token(client)
         try:
             return client.get_job(job_id, scope=scope)
         except JobsApiHTTPError as exc:
@@ -2414,6 +2452,7 @@ def _wait_for_latest_job(client: JobsApiClient) -> dict[str, Any]:
     """
     waiting_announced = False
     while True:
+        client = _client_with_fresh_token(client)
         try:
             latest = client.get_latest_job()
         except JobsApiHTTPError as exc:
@@ -2608,6 +2647,8 @@ def _drain_logs(
     post-``simulo run`` default follow — one follow loop, one
     exit-code-mirrors-outcome rule.
     """
+    if follow:
+        client = _client_with_fresh_token(client)
     offset = 0
     if tail_lines is not None:
         try:
@@ -2633,6 +2674,8 @@ def _drain_logs(
         # Not honored (old server): the loop below simply continues the full
         # history from where the server's offset-0 answer left off.
     while True:
+        if follow:
+            client = _client_with_fresh_token(client)
         try:
             chunk, offset, status, _ = client.get_log_chunk(job_id, offset, scope=scope)
         except JobsApiHTTPError as exc:
@@ -2770,9 +2813,9 @@ def _cmd_result(args: argparse.Namespace) -> int:
     announced on stderr.
     A job whose run announced typed outputs gets a second
     stderr line, ``⚠ 1 anomaly (non_finite_reward)`` (:func:`_outputs_flag_summary`)
-    — the result JSON itself is untouched (``stats["anomaly_captures"]`` stays
-    byte-identical; a byte stream is an output, a JSON scalar is a metric,
-    surfaced together but never merged). Both lines print to
+    while built-in training results omit anomaly-capture paths. Those paths
+    are exposed through the recordings and outputs commands instead. Both
+    lines print to
     stderr so stdout stays pure result JSON for pipelines. Best-effort: for
     an explicit JOB_ID this needs one extra ``get_job`` call, and a failure
     there (e.g. an older control plane) skips both lines rather than failing a
@@ -2806,6 +2849,13 @@ def _cmd_result(args: argparse.Namespace) -> int:
         if exc.status == 404:
             display_ref = _human_job_ref(job_id)
             hint_ref = display_ref if display_ref.startswith("job_") else "<JOB_ID>"
+            if (job_record or {}).get("job_type") == "export":
+                print(
+                    f"{_human_job_subject(job_id)} produces a bundle rather than a result. "
+                    f"List its outputs with `simulo outputs {hint_ref}`.",
+                    file=sys.stderr,
+                )
+                return 1
             print(
                 f"No result for {display_ref}: {_safe_cli_error_text(exc.message)}\n"
                 "A result exists once the job has finished and returned one — check `simulo jobs` "
@@ -8085,10 +8135,11 @@ def _build_parser() -> argparse.ArgumentParser:
     prepare = sub.add_parser(
         "prepare",
         help=(
-            "Check a Simulo app against the platform BEFORE submitting it — builds the manifest "
-            "and asks the platform whether it would work (pip version conflicts, invalid job "
-            "timeouts, and more). Imports your app file, same as `simulo run`. Never uploads "
-            "anything and never creates a job."
+            "Check a Simulo app against the platform BEFORE submitting it. Builds the manifest "
+            "and, when signed in, resolves its catalog asset references before asking whether it "
+            "would work (pip version conflicts, invalid job timeouts, and more). Signed-out or "
+            "unreachable asset checks are reported and skipped. Imports your app file, same as "
+            "`simulo run`. Never uploads anything and never creates a job."
         ),
     )
     prepare.add_argument("app_file", help="Path to the Python file declaring the simulo.App.")

{simulo-0.31.0 → simulo-0.31.2/src/simulo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo
-Version: 0.31.0
+Version: 0.31.2
 Summary: Python SDK and CLI for cloud-native robotics simulation, reinforcement learning, and robot policy training on managed GPUs.
 Author-email: Simulo Team <team@simulo.ai>
 License: BSD-3-Clause