simulo 0.33.0__tar.gz → 0.34.0__tar.gz

{simulo-0.33.0/src/simulo.egg-info → simulo-0.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo
-Version: 0.33.0
+Version: 0.34.0
 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
@@ -31,10 +31,12 @@ Classifier: Topic :: System :: Distributed Computing
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: simulo-interfaces<0.25,>=0.24.0
+Requires-Dist: simulo-interfaces<0.26,>=0.25.0
 Requires-Dist: mcap<2,>=1.3
 Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: usd-core<27,>=26.5
+Provides-Extra: viz
+Requires-Dist: simulo-viz<0.2,>=0.1.0; python_version >= "3.12" and extra == "viz"
 Provides-Extra: assets
 Requires-Dist: usd-core<27,>=26.5; extra == "assets"
 Provides-Extra: dev

{simulo-0.33.0 → simulo-0.34.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulo"
-version = "0.33.0"
+version = "0.34.0"
 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"
@@ -59,7 +59,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.24.0,<0.25",
+    "simulo-interfaces>=0.25.0,<0.26",
     "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
@@ -81,6 +81,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+viz = ["simulo-viz>=0.1.0,<0.2; python_version >= '3.12'"]
 # `assets` — kept for backward compatibility with `pip install
 # "simulo[assets]"` (the 0.13.0-era spelling): usd-core moved into the base
 # install above in 0.13.1, so this extra is now redundant (its dep is

{simulo-0.33.0 → simulo-0.34.0}/src/simulo/__init__.py

@@ -129,6 +129,7 @@ from simulo.interfaces import (
 # re-exported here like every other concrete authoring type — no exclusion
 # needed any more.
 from simulo.interfaces.authoring import (
+    ActionChannel,
     ArrowMarker,
     AssetEntity,
     AssetSource,
@@ -143,6 +144,8 @@ from simulo.interfaces.authoring import (
     DomeLight,
     GroundPlane,
     LightConfig,
+    LineMarker,
+    ObjectVariants,
     PointMarker,
     PolicyCheckpoint,
     PolicyInput,
@@ -210,6 +213,7 @@ __all__ = [
     "Digest",
     # authoring value types (eager, real) — the rest of the vocabulary the
     # lazy resolver below does not carry
+    "ActionChannel",
     "Collision",
     "RigidPhysics",
     "DeformableMaterial",
@@ -219,6 +223,7 @@ __all__ = [
     "USDAsset",
     "URDFAsset",
     "LightConfig",
+    "ObjectVariants",
     "DistantLight",
     "DomeLight",
     "TerrainConfig",
@@ -238,6 +243,7 @@ __all__ = [
     "SphereMarker",
     "ArrowMarker",
     "PointMarker",
+    "LineMarker",
     # lazy, mode-aware (the learning names + save_output)
     "ActuatorGainsConfig",
     "ArticulationConfig",

{simulo-0.33.0 → simulo-0.34.0}/src/simulo/_client/app.py

@@ -48,7 +48,9 @@ from typing import (
 
 from simulo._client import config, credentials, registry
 from simulo._client._runner import JobFailedError, JobHandle, JobResultUnavailable
+from simulo._client.repeatable_episodes import requested_repeatable_episodes
 from simulo._client.runtime import DEFAULT_RUNTIME
+from simulo._client.training_algorithm import validate_training_algorithm
 from simulo.interfaces.ids import JobId, parse_job_public_id
 from simulo.interfaces.platform import JobCallbackProtocol, JobType, normalize_job_tags
 from simulo.interfaces.platform.app import Mount
@@ -131,19 +133,43 @@ def spawn_recorder() -> Iterator[list["JobHandle"]]:
 # through arbitrary user code" reason.
 # ---------------------------------------------------------------------------
 
-_VIEWSTREAM_REQUESTED = False
+_VIEWSTREAM_REQUESTED: Optional[bool] = None
+_VIEWSTREAM_NOTICE: Optional[str] = None
 
 
 @contextlib.contextmanager
-def viewstream_requested(enabled: bool) -> Iterator[None]:
-    """Scope ``--viewstream`` for one ``simulo run`` submit call."""
-    global _VIEWSTREAM_REQUESTED
+def viewstream_requested(enabled: Optional[bool], *, notice: Optional[str] = None) -> Iterator[None]:
+    """Scope one resolved live-view request for one ``simulo run`` submit call."""
+    global _VIEWSTREAM_REQUESTED, _VIEWSTREAM_NOTICE
     previous = _VIEWSTREAM_REQUESTED
+    previous_notice = _VIEWSTREAM_NOTICE
     _VIEWSTREAM_REQUESTED = enabled
+    _VIEWSTREAM_NOTICE = notice
     try:
         yield
     finally:
         _VIEWSTREAM_REQUESTED = previous
+        _VIEWSTREAM_NOTICE = previous_notice
+
+
+# ---------------------------------------------------------------------------
+# 3D-recording ambient signal — `simulo run --record-3d COPIES` scopes an
+# execution option without placing it in package arguments or the manifest.
+# ---------------------------------------------------------------------------
+
+_RECORDING_COPIES_REQUESTED: Optional[int] = None
+
+
+@contextlib.contextmanager
+def recording_copies_requested(copies: Optional[int]) -> Iterator[None]:
+    """Scope an optional 3D recording copy count for one submit."""
+    global _RECORDING_COPIES_REQUESTED
+    previous = _RECORDING_COPIES_REQUESTED
+    _RECORDING_COPIES_REQUESTED = copies
+    try:
+        yield
+    finally:
+        _RECORDING_COPIES_REQUESTED = previous
 
 
 # ---------------------------------------------------------------------------
@@ -526,7 +552,9 @@ def _spawn_cloud(
     package_path: Path,
     creds: Optional[dict[str, Any]],
     *,
-    viewstream: bool = False,
+    viewstream: Optional[bool] = None,
+    recording_copies: Optional[int] = None,
+    repeatable_episodes: Optional[bool] = None,
     input_checkpoint: Optional[str] = None,
     compare_checkpoint: Optional[str] = None,
     require_success: Optional[float] = None,
@@ -689,7 +717,7 @@ def _spawn_cloud(
             archive_size=len(archive_bytes),
             job_type=job_type,
             input_checkpoint=input_checkpoint,
-            viewstream=viewstream,
+            viewstream=viewstream is True,
             assets=[] if not asset_refs else None,
         )
         deferred_stdout, deferred_stderr = _handle_preflight_outcome(outcome, job_name=job_name)
@@ -721,6 +749,8 @@ def _spawn_cloud(
         job_name=job_name,
         args=args,
         viewstream=viewstream,
+        recording_copies=recording_copies,
+        repeatable_episodes=repeatable_episodes,
         input_checkpoint=input_checkpoint,
         compare_checkpoint=compare_checkpoint,
         require_success=require_success,
@@ -732,6 +762,14 @@ def _spawn_cloud(
         tags=tags,
         manifest_version=manifest_version,
     )
+    # A submitted entrypoint can call ``spawn()`` more than once.  The
+    # resolved notice describes the run-level opt-in, so print it once only
+    # after the first successful job-create response.  Do not consume it when
+    # create_job raises: then the run did not successfully submit anything.
+    global _VIEWSTREAM_NOTICE
+    if _VIEWSTREAM_NOTICE is not None:
+        print(_VIEWSTREAM_NOTICE, file=sys.stderr)
+        _VIEWSTREAM_NOTICE = None
 
     raw_public_id = record.get("public_id")
     try:
@@ -813,6 +851,12 @@ class JobFunction:
         # job/success contract as ``simulo run``.  This happens before the
         # intent marker, bundle construction, asset resolution, or network I/O.
         self._app.validate_job_submission(self._spec.name)
+        if self._spec.job_type is JobType.TRAIN:
+            parameter = inspect.signature(self._spec.fn).parameters.get("algorithm")
+            if "algorithm" in kwargs:
+                validate_training_algorithm(kwargs["algorithm"])
+            elif parameter is not None and parameter.default is not inspect.Parameter.empty:
+                validate_training_algorithm(parameter.default)
 
         # Intent-to-submit is recorded FIRST — before any packaging or network
         # I/O — so a submit that fails partway (or times out AFTER the server
@@ -861,6 +905,8 @@ class JobFunction:
                         package_path,
                         creds,
                         viewstream=_VIEWSTREAM_REQUESTED,
+                        recording_copies=_RECORDING_COPIES_REQUESTED,
+                        repeatable_episodes=requested_repeatable_episodes(),
                         input_checkpoint=_INPUT_CHECKPOINT_REF,
                         compare_checkpoint=_COMPARE_CHECKPOINT_REF,
                         require_success=_REQUIRE_SUCCESS,

{simulo-0.33.0 → simulo-0.34.0}/src/simulo/_client/bundle.py

@@ -4,9 +4,10 @@ Shared by ``simulo run`` (the CLI) and ``JobFunction.spawn`` — the *submit* pa
 discover the app's metadata and write the package (manifest + source bundle) to
 disk. The manifest builder reads only the public ``App`` surface, so it works in
 discovery mode (where submit runs). ``ensure_bundle`` memoises the written package
-per *submission* — ``(app, entry_file, job_name, args)`` — so re-submitting the
-same file and job with the same args reuses the package, while a second spawn with
-a different entry file, job, or args writes a distinct package (no clobber).
+per *submission* — ``(app, entry_file, job_name, args, captured assets)`` — so
+re-submitting the same file and job with the same args and captured assets reuses
+the package. Package identity hashes source, entry file, job, canonical args,
+and the canonical asset list; changing any of those writes a distinct package.
 
 Submit NEVER executes a job and NEVER invokes the backend — it only writes the
 package. This module imports no heavy library; it stays on the torch-free side of
@@ -59,9 +60,9 @@ DEFAULT_OUT_SUBPATH = (".simulo", "packages")
 #: capture — see ``asset.py``) — included so a LATER spawn() in the same process,
 #: after user code has constructed MORE assets since an earlier spawn() with
 #: the identical ``(app, entry_file, job_name, args)``, is never served a stale cached bundle
-#: whose ``resources`` predates those constructions (``package_id`` itself never
-#: changes with the asset set — see the package-hash-invariance rule — so the
-#: `package_id` re-check below cannot by itself catch this staleness).
+#: whose ``resources`` predates those constructions. The package id also hashes
+#: resources, but a cache hit does not rebuild the manifest or recompute the id,
+#: so this key must still distinguish the captured asset set.
 _BUNDLE_CACHE: dict[tuple[int, str, str, str, tuple[str, ...]], tuple[Path, str]] = {}
 
 
@@ -197,7 +198,8 @@ def ensure_bundle(
     This is the *submit* primitive: the manifest is built from the live app object
     (no second discovery import) with the submitted job's ``args`` recorded, and
     the source tree is written to ``<out>/<bundle_dir_name(package_id)>/`` — the
-    per-submission directory keyed on source + entry file + ``job_name`` + ``args`` (named by
+    per-submission directory keyed on source + entry file + ``job_name`` + canonical
+    ``args`` + canonical asset list (named by
     the id's short, filesystem-safe form; see ``packaging.bundle_dir_name``).
     Memoised per submission (``(id(app), entry_file, job_name, canonical_json(args), sorted
     extra_assets uris)``) so re-submitting the same job with the same args AND the

{simulo-0.33.0 → simulo-0.34.0}/src/simulo/_client/cli_context.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import argparse
 import os
 import sys
-from typing import Callable, Optional, Sequence
+from typing import Any, Callable, Optional, Sequence
 
 from simulo._client import config, credentials, preview_report
 from simulo._client.app import (
@@ -43,11 +43,32 @@ def _resolve_client_context() -> tuple[str, Optional[str]]:
     return base_url, token
 
 
-def _client_with_fresh_token(client: JobsApiClient) -> JobsApiClient:
+def _client_with_fresh_token(client: JobsApiClient, initial_credentials: dict[str, Any]) -> 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:
+    if not credentials.credentials_file_exists():
+        # Preserve the selected-file error and the manual-token fallback.
+        if os.environ.get(credentials.CREDENTIALS_FILE_ENV) is not None:
+            credentials.load_credentials()
         return client
+    creds = credentials.load_credentials()
+    if (
+        not initial_credentials
+        or config.resolve_base_url(creds).rstrip("/") != client.base_url
+        or any(
+            creds.get(field) != initial_credentials.get(field)
+            for field in ("api_base_url", "user_email", "active_organization_id")
+        )
+    ):
+        raise credentials.CredentialsError(
+            "Your saved sign-in changed while this command was running "
+            "(different user, organization or server). Re-run the command."
+        )
+    # Refresh the checked snapshot directly. A second file read could adopt a
+    # different login between this guard and the refresh request.
+    if credentials.is_expired(creds):
+        creds = credentials.refresh_access_token(
+            creds, base_url=client.base_url, min_validity_s=credentials._EXPIRY_SKEW_S
+        )
     return JobsApiClient(client.base_url, token=str(creds["access_token"]))
 
 

{simulo-0.33.0 → simulo-0.34.0}/src/simulo/_client/cli_job_reporting.py

@@ -7,9 +7,8 @@ import sys
 import time
 from typing import Any, Callable, Optional, TypeVar
 
-from simulo._client import credentials, http, preview_report
+from simulo._client import credentials, preview_report
 from simulo._client.cli_context import _client_with_fresh_token
-from simulo._client.cli_errors import caused_by
 from simulo._client.cli_rendering import _safe_table_cell
 from simulo._client.cli_text import (
     _MAX_OUTPUTS_LINE_CHARS,
@@ -18,11 +17,10 @@ from simulo._client.cli_text import (
     _safe_cli_error_text,
     _safe_single_line_text,
 )
-from simulo._client.cli_waiting import GaveUpUnavailable, _retry_transient, _sleep_for_rate_limit
+from simulo._client.cli_waiting import _retry_transient, _sleep_for_rate_limit
 from simulo._client.jobs_api import JobsApiClient, JobsApiError, JobsApiHTTPError
 from simulo.interfaces.platform.enums import JobStatus
 from simulo.interfaces.platform.outputs import OUTPUT_FLAG_ANOMALY, OUTPUT_FLAG_OUTPUT_DROPPED
-from simulo.interfaces.platform.preview import PREVIEW_REPORT_SCHEMA_VERSION
 from simulo.interfaces.platform.runs import (
     JOB_SCOPE_MINE,
     LOG_ARCHIVE_EXPIRED_CODE,
@@ -31,9 +29,12 @@ from simulo.interfaces.platform.runs import (
     LOG_TAIL_MAX_BYTES,
     TERMINAL_JOB_STATUSES,
 )
+from simulo.interfaces.platform.submit import LIVE_VIEW_UNAVAILABLE_WARNING_CODE
 
 #: ``--follow`` poll cadence. Module-level so tests can shrink it.
 _FOLLOW_POLL_INTERVAL_S = 0.7
+#: Keep warning refreshes aligned with the worker's default heartbeat cadence.
+_LIVE_VIEW_WARNING_POLL_INTERVAL_S = 15.0
 _T = TypeVar("_T")
 #: ``simulo logs --follow`` starts from the last this-many LINES of existing
 #: output by default (``tail -f`` style) — override with ``--tail N`` /
@@ -56,6 +57,8 @@ _COMPLETED_STATUS = str(JobStatus.COMPLETED)
 _QUEUED_STATUS = str(JobStatus.QUEUED)
 _RUNNING_STATUS = str(JobStatus.RUNNING)
 _CANCELLED_STATUS = str(JobStatus.CANCELLED)
+_ORG_RUNNING_LIMIT_REASON = "org_running_limit_reached"
+_ORG_RUNNING_LIMIT_MESSAGE = "waiting for a running job in your organization to finish"
 #: The terminal statuses that carry a self-diagnosis reason (JobRecord's
 #: ``status_reason``/``status_detail``): a failed, cancelled, or timed-out
 #: job. A cleanly ``completed`` job has none.
@@ -144,7 +147,7 @@ def _echo_report_stages(echo: Callable[[str], None], report: dict[str, Any]) ->
     check and its status, prints every row's detail, the owner of a warning or
     failure, and where to look in the recording — see
     :func:`preview_report.echo_preview_stages`."""
-    if report.get("report_schema_version") == PREVIEW_REPORT_SCHEMA_VERSION:
+    if preview_report.is_preview_report(report):
         preview_report.echo_preview_stages(echo, report)
         return
     for stage in report.get("stages") or []:
@@ -216,22 +219,17 @@ def _outcome_unknown_text(reason: str, job_id: str) -> str:
     )
 
 
-def _fresh_client(client: JobsApiClient, job_id: str, follow: bool) -> JobsApiClient:
+def _fresh_client(
+    client: JobsApiClient, job_id: str, follow: bool, initial_credentials: dict[str, Any]
+) -> JobsApiClient:
     """Refresh the access token; while *follow*ing, a refresh that cannot reach
     the server is the same unknown-outcome give-up as a failed log read, not a
     credentials error that callers report as the job failing."""
-    try:
-        return _client_with_fresh_token(client)
-    except credentials.TokenRefreshError as exc:
-        if follow and caused_by(exc, http.HttpUnavailable):
-            raise GaveUpUnavailable(
-                f"{_outcome_unknown_text('the session could not be refreshed', job_id)}; {exc}"
-            ) from exc
-        raise
+    return _followed(lambda: _client_with_fresh_token(client, initial_credentials), job_id, follow)
 
 
 def _followed(call: Callable[[], _T], job_id: str, follow: bool) -> _T:
-    """Run a log read, retrying a transient failure only while *follow*ing a job.
+    """Run a log read or token refresh, retrying only while *follow*ing a job.
 
     A one-shot read reports the error as before; a follow that keeps failing
     says the job's outcome is unknown and names how to check it.
@@ -333,6 +331,7 @@ def _drain_logs(
     follow: bool,
     tail_lines: Optional[int] = None,
     scope: str = JOB_SCOPE_MINE,
+    initial_credentials: Optional[dict[str, Any]] = None,
 ) -> int:
     """Print log chunks; ``follow`` polls to a terminal status.
 
@@ -345,8 +344,12 @@ def _drain_logs(
     post-``simulo run`` default follow — one follow loop, one
     exit-code-mirrors-outcome rule.
     """
+    if initial_credentials is None:
+        initial_credentials = credentials.load_credentials() if credentials.credentials_file_exists() else {}
     if follow:
-        client = _fresh_client(client, job_id, follow)
+        client = _fresh_client(client, job_id, follow, initial_credentials)
+    warning_reported = _emit_live_view_warning(client, job_id, scope=scope)
+    next_warning_check_at = time.monotonic() + _LIVE_VIEW_WARNING_POLL_INTERVAL_S
     offset = 0
     if tail_lines is not None:
         try:
@@ -373,7 +376,7 @@ def _drain_logs(
         # history from where the server's offset-0 answer left off.
     while True:
         if follow:
-            client = _fresh_client(client, job_id, follow)
+            client = _fresh_client(client, job_id, follow, initial_credentials)
         try:
             chunk, offset, status, _ = _followed(
                 lambda: client.get_log_chunk(job_id, offset, scope=scope), job_id, follow
@@ -410,11 +413,16 @@ def _drain_logs(
             # and a completed job's typed outputs summary (e.g. `completed ⚠ 1
             # anomaly (non_finite_reward)`) gets the identical best-effort
             # treatment — on stderr, never touching stdout or the exit code.
+            if not warning_reported:
+                warning_reported = _emit_live_view_warning(client, job_id, scope=scope)
             if status in _FAILURE_STATUS_STRINGS:
                 _emit_terminal_reason(client, job_id, scope=scope)
             elif status == _COMPLETED_STATUS:
                 _emit_outputs_summary(client, job_id, scope=scope)
             return 0 if status == _COMPLETED_STATUS else 1
+        if not warning_reported and time.monotonic() >= next_warning_check_at:
+            warning_reported = _emit_live_view_warning(client, job_id, scope=scope)
+            next_warning_check_at = time.monotonic() + _LIVE_VIEW_WARNING_POLL_INTERVAL_S
         time.sleep(_FOLLOW_POLL_INTERVAL_S)
 
 
@@ -500,12 +508,15 @@ def _report_log_archive_unavailable(exc: JobsApiHTTPError, job_id: str) -> int:
 
 
 def _failure_reason_code(record: dict[str, Any]) -> Optional[str]:
-    """The short machine-readable ``reason_code`` of a failed/cancelled job, or
-    ``None`` — the wire ``JobRecord.status_reason`` (additive; absent on a
-    control plane that predates the field, which reads as "no reason")."""
-    if str(record.get("status", "")) not in _FAILURE_STATUS_STRINGS:
-        return None
+    """The displayed reason for a failed/cancelled job, or the known queued
+    organization-running-limit wait. Other queued reasons remain hidden until
+    they have a deliberate CLI rendering."""
+    status = str(record.get("status", ""))
     reason = record.get("status_reason")
+    if status == _QUEUED_STATUS and reason == _ORG_RUNNING_LIMIT_REASON:
+        return _ORG_RUNNING_LIMIT_MESSAGE
+    if status not in _FAILURE_STATUS_STRINGS:
+        return None
     if isinstance(reason, str) and reason.strip():
         return _safe_cli_error_text(reason.strip())
     return None
@@ -540,6 +551,35 @@ def _terminal_reason_line(record: dict[str, Any]) -> Optional[str]:
     return line
 
 
+def _live_view_warning_message(record: dict[str, Any]) -> Optional[str]:
+    """The known non-terminal live-view warning, or ``None``.
+
+    ``warning_code`` and ``warning_message`` are separate from terminal
+    failure fields. Training can continue while live view is unavailable.
+    """
+    if str(record.get("status", "")) not in {_RUNNING_STATUS, _COMPLETED_STATUS}:
+        return None
+    if record.get("warning_code") != LIVE_VIEW_UNAVAILABLE_WARNING_CODE:
+        return None
+    message = record.get("warning_message")
+    if not isinstance(message, str) or not message.strip():
+        return None
+    return _safe_cli_error_text(message.strip())
+
+
+def _emit_live_view_warning(client: JobsApiClient, job_id: str, *, scope: str = JOB_SCOPE_MINE) -> bool:
+    """Print the live-view warning to stderr and return whether it was present."""
+    try:
+        record = client.get_job(job_id, scope=scope)
+    except JobsApiError:
+        return False
+    message = _live_view_warning_message(record)
+    if message is not None:
+        print(f"warning: {message}", file=sys.stderr, flush=True)
+        return True
+    return False
+
+
 def _emit_terminal_reason(client: JobsApiClient, job_id: str, *, scope: str = JOB_SCOPE_MINE) -> None:
     """Print a failed/cancelled job's terminal reason (:func:`_terminal_reason_line`)
     to stderr, or do nothing. Best-effort: a re-fetch that 404s (or any HTTP

{simulo-0.33.0 → simulo-0.34.0}/src/simulo/_client/cli_waiting.py

@@ -6,6 +6,7 @@ import sys
 import time
 from typing import Callable, Optional, TypeVar
 
+from simulo._client import credentials
 from simulo._client.jobs_api import JobsApiHTTPError, JobsApiUnavailable
 from simulo.interfaces.platform.runs import LOG_ARCHIVE_READ_FAILED_CODE
 
@@ -13,7 +14,8 @@ _T = TypeVar("_T")
 
 #: How long a printed "waiting..." line stays valid before ``_WaitAnnouncer``
 #: re-prints it — so a multi-minute wait doesn't read as frozen on a real
-#: tty (critic MINOR; no prior periodic-reannounce precedent in this file,
+#: tty. Non-TTY output announces each wait only once.
+#: (critic MINOR; no prior periodic-reannounce precedent in this file,
 #: so this is a new, small, self-contained helper rather than a bigger
 #: refactor of the existing single-print wait loops).
 _SPINNER_REANNOUNCE_INTERVAL_S = 15.0
@@ -23,8 +25,8 @@ class _WaitAnnouncer:
     """Prints *message* immediately, then re-prints it every
     ``_SPINNER_REANNOUNCE_INTERVAL_S`` while ``poll()`` keeps being called —
     so a multi-minute queued-wait or gap-retry doesn't look frozen on a real
-    terminal. One small stateful helper shared by both wait loops below
-    rather than duplicating the timer bookkeeping twice.
+    terminal. Non-TTY output prints it once. One small stateful helper shared
+    by both wait loops below rather than duplicating the timer bookkeeping twice.
     """
 
     def __init__(self, message: str) -> None:
@@ -33,7 +35,9 @@ class _WaitAnnouncer:
 
     def poll(self) -> None:
         now = time.monotonic()
-        if self._last_announced_at is None or now - self._last_announced_at >= _SPINNER_REANNOUNCE_INTERVAL_S:
+        if self._last_announced_at is None or (
+            sys.stderr.isatty() and now - self._last_announced_at >= _SPINNER_REANNOUNCE_INTERVAL_S
+        ):
             print(self._message, file=sys.stderr, flush=True)
             self._last_announced_at = now
 
@@ -123,8 +127,10 @@ def _retry_transient(call: Callable[[], _T], *, give_up: Callable[[str], str]) -
     """Run ``call()``, retrying a transient failure a bounded number of times.
 
     Retried: a load-balancer 502/503/504 and ``JobsApiUnavailable`` (connection
-    reset or refused, or the client's request timeout). A 429 and every other
-    error go straight to the caller, which owns their policy, and a ``503``
+    reset or refused, or the client's request timeout), including those wrapped
+    in ``TokenRefreshError``. A refresh rejected with 401/403 is never retried.
+    A 429 and every other error go straight to the caller, which owns their
+    policy, and a ``503``
     carrying the log-read-failure code is left alone because the caller already
     explains it in its own words. After the last retry the failure becomes a
     ``GaveUpHTTPError`` (code ``server_unavailable``) or ``GaveUpUnavailable``
@@ -138,26 +144,32 @@ def _retry_transient(call: Callable[[], _T], *, give_up: Callable[[str], str]) -
     while True:
         try:
             return call()
-        except JobsApiHTTPError as exc:
-            if exc.status not in _TRANSIENT_5XX_STATUSES or exc.code == LOG_ARCHIVE_READ_FAILED_CODE:
+        except (JobsApiHTTPError, JobsApiUnavailable, credentials.TokenRefreshError) as exc:
+            # Refresh wraps HTTP failures in a credential error. Classify its
+            # cause so a server outage is retried without retrying a rejection.
+            failure = exc.__cause__ if isinstance(exc, credentials.TokenRefreshError) else exc
+            if isinstance(failure, JobsApiHTTPError):
+                if failure.status not in _TRANSIENT_5XX_STATUSES or failure.code == LOG_ARCHIVE_READ_FAILED_CODE:
+                    raise
+                delay = next(delays, None)
+                if delay is None:
+                    raise GaveUpHTTPError(
+                        failure.status,
+                        "server_unavailable",
+                        give_up(f"the server kept returning HTTP {failure.status}"),
+                    ) from exc
+                what = f"the server returned HTTP {failure.status}"
+            elif isinstance(failure, JobsApiUnavailable):
+                delay = next(delays, None)
+                if delay is None:
+                    raise GaveUpUnavailable(
+                        f"{give_up('the connection to the server kept failing')}; {failure}"
+                    ) from exc
+                what = "the connection to the server failed"
+                if first_note:
+                    what += f": {' '.join(str(failure).split()).rstrip('.')}"
+            else:
                 raise
-            delay = next(delays, None)
-            if delay is None:
-                raise GaveUpHTTPError(
-                    exc.status,
-                    "server_unavailable",
-                    give_up(f"the server kept returning HTTP {exc.status}"),
-                ) from exc
-            what = f"the server returned HTTP {exc.status}"
-        except JobsApiUnavailable as exc:
-            delay = next(delays, None)
-            if delay is None:
-                raise GaveUpUnavailable(f"{give_up('the connection to the server kept failing')}; {exc}") from exc
-            what = "the connection to the server failed"
-            if first_note:
-                # Name the cause once, so a mistyped SIMULO_API_URL can be
-                # spotted on the first line instead of after the last retry.
-                what += f": {' '.join(str(exc).split()).rstrip('.')}"
         print(f"note: {what}; retrying in {delay:g}s...", file=sys.stderr, flush=True)
         first_note = False
         time.sleep(delay)

{simulo-0.33.0 → simulo-0.34.0}/src/simulo/_client/commands/assets.py

@@ -60,6 +60,7 @@ from simulo.interfaces.platform.asset_catalog import (
     ASSET_ARCHIVE_TOO_LARGE_CODE,
     ASSET_KINDS,
     ASSET_NOT_EXPORTABLE_CODE,
+    ASSET_NOT_FOUND_CODE,
     ASSET_SLUG_PATTERN,
     ASSET_STORAGE_QUOTA_EXCEEDED_CODE,
     ASSET_TOO_MANY_CONCURRENT_UPLOADS_CODE,
@@ -165,6 +166,7 @@ def _friendly_asset_error(exc: AssetApiHTTPError) -> str:
         )
     if exc.code in (
         ASSET_ARCHIVE_TOO_LARGE_CODE,
+        ASSET_NOT_FOUND_CODE,
         ASSET_TOO_MANY_FILES_CODE,
         ASSET_TOO_MANY_CONCURRENT_UPLOADS_CODE,
         ASSET_VERSION_NOT_UPLOADING_CODE,
@@ -513,7 +515,7 @@ def _echo_facts_block(echo: Callable[[str], None], facts: dict[str, Any]) -> Non
     # step_cost_indicator" — PR-11's facts.py emits EXACTLY these names).
     collision = facts.get("collision_shape_count")
     if collision is not None:
-        extras.append(f"{collision} collision meshes")
+        extras.append(f"{collision} collision {'mesh' if collision == 1 else 'meshes'}")
     units = facts.get("units")
     if units:
         extras.append(f"units {units}")
@@ -1730,9 +1732,10 @@ def _resolve_target_version(
                     base_url=base_url,
                     token=token,
                 )
+            ref = _asset_display_ref(publisher=parsed.publisher, kind=kind, name=name, version=None)
             return None, (
-                f"{kind}/{name} has no version v{parsed.version} in the catalog. "
-                f"See its versions with `simulo asset inspect {kind}/{name}`."
+                f"{ref} has no version v{parsed.version} in the catalog. "
+                f"See its versions with `simulo asset inspect {ref}`."
             )
         if not _has_known_asset_version_status(matches[0]):
             return None, _ASSET_UNRECOGNIZED_VERSION_STATUS_MESSAGE