simulo 0.34.0__tar.gz → 0.35.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulo
-Version: 0.34.0
+Version: 0.35.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
@@ -9,7 +9,7 @@ Project-URL: Documentation, https://docs.simulo.ai
 Project-URL: Quickstart, https://docs.simulo.ai/getting-started/quickstart/
 Project-URL: Examples, https://github.com/simulo-org/simulo-samples
 Project-URL: Console, https://console.simulo.ai
-Keywords: simulo,robotics,robotics simulation,robot training,robot learning,reinforcement learning,cloud robotics,cloud simulation,GPU simulation,policy training,physical AI,embodied AI,NVIDIA Isaac Sim,Isaac Lab,OpenUSD,USD,URDF,ONNX,MCAP,Python SDK
+Keywords: simulo,robotics,robotics simulation,robot training,robot learning,reinforcement learning,cloud robotics,cloud simulation,GPU simulation,policy training,physical AI,embodied AI,OpenUSD,USD,URDF,ONNX,MCAP,Python SDK
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -31,7 +31,7 @@ Classifier: Topic :: System :: Distributed Computing
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: simulo-interfaces<0.26,>=0.25.0
+Requires-Dist: simulo-interfaces<0.27,>=0.26.0
 Requires-Dist: mcap<2,>=1.3
 Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: usd-core<27,>=26.5
@@ -40,7 +40,7 @@ Requires-Dist: simulo-viz<0.2,>=0.1.0; python_version >= "3.12" and extra == "vi
 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: black==26.10.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"
@@ -124,7 +124,7 @@ simulo policy get policy_x:best   # download a verified checkpoint
 simulo export policy_x:best       # export a verified ONNX bundle
 simulo recordings                 # download MCAP rollout recordings
 simulo outputs                    # retrieve other saved outputs
-simulo view                       # view a running --viewstream job in 3D
+simulo view                       # view a running job in 3D (live view is on by default)
 simulo cancel                     # stop a queued or running job
 ```
 

{simulo-0.34.0 → simulo-0.35.0}/PYPI.md

@@ -66,7 +66,7 @@ simulo policy get policy_x:best   # download a verified checkpoint
 simulo export policy_x:best       # export a verified ONNX bundle
 simulo recordings                 # download MCAP rollout recordings
 simulo outputs                    # retrieve other saved outputs
-simulo view                       # view a running --viewstream job in 3D
+simulo view                       # view a running job in 3D (live view is on by default)
 simulo cancel                     # stop a queued or running job
 ```
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulo"
-version = "0.34.0"
+version = "0.35.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"
@@ -23,8 +23,6 @@ keywords = [
     "policy training",
     "physical AI",
     "embodied AI",
-    "NVIDIA Isaac Sim",
-    "Isaac Lab",
     "OpenUSD",
     "USD",
     "URDF",
@@ -59,7 +57,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.25.0,<0.26",
+    "simulo-interfaces>=0.26.0,<0.27",
     "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
@@ -70,6 +68,8 @@ dependencies = [
     # featherweight promise below (that promise was about avoiding
     # usd-core's tens of MB via an opt-in extra; usd-core itself joined the
     # base footprint in 0.13.1 — see its own comment just below).
+    # Uncapped on purpose: the floor keeps the hardened XML parser; an upper
+    # bound is added only when a release breaks it.
     "defusedxml>=0.7.1",
     # usd-core: simulator-free but tens of MB — moved from the `assets`
     # extra into the base install in 0.13.1 so `pip install simulo` covers
@@ -105,7 +105,7 @@ assets = ["usd-core>=26.5,<27"]
 # `pytest-timeout` is pinned EXACT because it enforces the suite's hang bound;
 # changing the plugin under an unchanged timeout would change that guard's behavior.
 dev = [
-    "black==26.5.1",
+    "black==26.10.1",
     "isort==8.0.1",
     "ruff==0.15.21",
     "mypy==2.3.0",
@@ -194,6 +194,7 @@ markers = [
     "isaac: requires NVIDIA Isaac Sim / IsaacLab (skipped on dev machines and in PR CI)",
     "gpu: requires a CUDA GPU (skipped on dev machines and in PR CI)",
     "requires_execution_backend: end-to-end test that needs a live execution backend in the loop; skipped in CPU/unit runs",
+    "smoke: a short fundamental-path test; the hosted smoke job in simulo-ci.yml runs only these, and local CI runs every test",
 ]
 
 # --- Formatters / linters --------------------------------------------------

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

@@ -316,8 +316,13 @@ def __getattr__(name: str) -> object:
     Fires only for attributes missing from the module dict — i.e. never for the
     real platform exports above. Delegates the learning names to the thin
     client's internal resolver (discovery stand-in vs. real
-    ``simulo.core`` class, by mode); everything else is a genuine ``AttributeError``.
+    ``simulo.core`` class, by mode), and read ``__version__`` from installed
+    package metadata on demand. Unknown names raise ``AttributeError``.
     """
+    if name == "__version__":
+        from importlib.metadata import version
+
+        return version("simulo")
     if name in _LEARNING_NAMES:
         return _resolve_learning(name)
     removed_hints = {

{simulo-0.34.0 → simulo-0.35.0}/src/simulo/_client/_runner.py

@@ -23,7 +23,7 @@ from __future__ import annotations
 
 import time
 from pathlib import Path
-from typing import Any, NoReturn, Optional
+from typing import Any, Mapping, NoReturn, Optional
 
 from simulo.interfaces.ids import JobId, JobPublicId
 from simulo.interfaces.platform.enums import JobStatus, JobType
@@ -91,6 +91,8 @@ class JobHandle:
         base_url: Optional[str] = None,
         token: Optional[str] = None,
         job_type: Optional[JobType] = None,
+        runtime_budget_s: Optional[int] = None,
+        job_args: Optional[Mapping[str, Any]] = None,
         input_checkpoint: Optional[str] = None,
         compare_checkpoint: Optional[str] = None,
         deferred_stdout: str = "",
@@ -104,6 +106,8 @@ class JobHandle:
         self._base_url = base_url
         self._token = token
         self._job_type = job_type
+        self._runtime_budget_s = runtime_budget_s
+        self._job_args = dict(job_args or {})
         self._input_checkpoint = input_checkpoint
         self._compare_checkpoint = compare_checkpoint
         self._deferred_stdout = deferred_stdout
@@ -149,6 +153,16 @@ class JobHandle:
         """Declared type for a cloud submission; absent on legacy local handles."""
         return self._job_type
 
+    @property
+    def runtime_budget_s(self) -> Optional[int]:
+        """The effective server-resolved time limit, in seconds, when served."""
+        return self._runtime_budget_s
+
+    @property
+    def job_args(self) -> Mapping[str, Any]:
+        """Training arguments for submit guidance, including declared defaults when known."""
+        return self._job_args
+
     @property
     def input_checkpoint(self) -> Optional[str]:
         """Policy checkpoint requested with ``simulo run --from``."""

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

@@ -50,12 +50,12 @@ 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.system_requests import effective_resources, validate_resources
 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
 from simulo.interfaces.platform.enums import SystemType
-from simulo.interfaces.platform.systems import SYSTEM_SPECS
 
 if TYPE_CHECKING:  # typing-only; avoids a module-scope dependency on the HTTP client
     from simulo._client.preflight_api import PreflightOutcome
@@ -564,6 +564,7 @@ def _spawn_cloud(
     app_name: Optional[str] = None,
     job_type: JobType,
     tags: Sequence[str] = (),
+    job_args: Optional[Mapping[str, Any]] = None,
 ) -> JobHandle:
     """Tar the bundle, preflight it, upload it, create the job, and return a
     cloud JobHandle.
@@ -627,7 +628,7 @@ def _spawn_cloud(
     job-create call's top-level ``assets`` field, never ``args``.
     """
     from simulo._client.asset_pins import (
-        DEFAULT_ASSET_RUNTIME,
+        asset_runtime_for_runtime_id,
         collect_asset_refs,
         resolve_and_pin_assets,
     )
@@ -658,15 +659,12 @@ def _spawn_cloud(
     package_id = str(package_id)
     source_digest = str(manifest.get("source_digest", ""))
     args = dict(manifest.get("args") or {})
-    # The requested GPU system tier (system-tier-catalog-1362, M50-persistence)
-    # — already validated at `@app.job(system=...)` decoration time and
-    # recorded on THIS job's own manifest entry as `resources["system"]`
-    # (the tier's wire value, e.g. "tier1"; see `decorate()`'s
-    # `resources["system"] = system.value`). Read from the already-parsed
-    # manifest rather than threaded in as a new parameter, since the value
-    # already lives there, keyed by this same `job_name`.
+    # CLI selections override this job's declared resources for this submit.
+    # They never enter args or rewrite the packaged manifest. Omitted options
+    # retain their existing wire representation for servers awaiting adoption.
     job_entry = manifest.get("jobs", {}).get(job_name) or {}
-    system = (job_entry.get("resources") or {}).get("system")
+    allocation = effective_resources(job_entry.get("resources") or {})
+    system = allocation.pop("system", None)
     manifest_version = manifest.get("manifest_version")
     if not isinstance(manifest_version, int) or isinstance(manifest_version, bool):
         raise RuntimeError(
@@ -719,6 +717,8 @@ def _spawn_cloud(
             input_checkpoint=input_checkpoint,
             viewstream=viewstream is True,
             assets=[] if not asset_refs else None,
+            **({"system": system} if system is not None else {}),
+            **allocation,
         )
         deferred_stdout, deferred_stderr = _handle_preflight_outcome(outcome, job_name=job_name)
 
@@ -728,13 +728,15 @@ def _spawn_cloud(
     # package is uploaded — so a missing/unpinned/unvalidated ref fails in seconds.
     # Returns the top-level `assets: [{ref, digest}]` for create_job; `[]`
     # when the app mounts no registry assets (no resolve call is made then).
-    asset_pins = resolve_and_pin_assets(
-        client,
-        collect_asset_refs(manifest),
-        runtime=DEFAULT_ASSET_RUNTIME,
-        frozen=frozen_assets,
-        strict=strict_assets,
-    )
+    asset_pins: list[dict[str, str]] = []
+    if asset_refs:
+        asset_pins = resolve_and_pin_assets(
+            client,
+            asset_refs,
+            runtime=asset_runtime_for_runtime_id(str(manifest["runtime_id"])),
+            frozen=frozen_assets,
+            strict=strict_assets,
+        )
 
     client.create_package(
         package_id=package_id,
@@ -748,6 +750,7 @@ def _spawn_cloud(
         package_id=package_id,
         job_name=job_name,
         args=args,
+        runtime_id=str(manifest["runtime_id"]),
         viewstream=viewstream,
         recording_copies=recording_copies,
         repeatable_episodes=repeatable_episodes,
@@ -761,6 +764,7 @@ def _spawn_cloud(
         job_type=job_type,
         tags=tags,
         manifest_version=manifest_version,
+        **allocation,
     )
     # A submitted entrypoint can call ``spawn()`` more than once.  The
     # resolved notice describes the run-level opt-in, so print it once only
@@ -794,6 +798,8 @@ def _spawn_cloud(
         base_url=base_url,
         token=token,
         job_type=job_type,
+        runtime_budget_s=record.get("runtime_budget_s"),
+        job_args=job_args if job_args is not None else args,
         input_checkpoint=input_checkpoint,
         compare_checkpoint=compare_checkpoint,
         deferred_stdout=deferred_stdout,
@@ -916,6 +922,12 @@ class JobFunction:
                         app_name=self._app.name,
                         job_type=self._spec.job_type,
                         tags=_JOB_TAGS_REQUESTED,
+                        job_args={
+                            name: parameter.default
+                            for name, parameter in inspect.signature(self._spec.fn).parameters.items()
+                            if parameter.default is not inspect.Parameter.empty
+                        }
+                        | kwargs,
                     )
 
                 if _SPAWN_RECORDER is None:
@@ -1302,6 +1314,8 @@ class App:
         type: Union[JobType, str],
         callbacks: Sequence[JobCallbackProtocol] = ...,
         system: Optional[SystemType] = ...,
+        gpus: Optional[int] = ...,
+        gpus_per_node: Optional[int] = ...,
         timeout: Optional[int] = ...,
         retries: int = ...,
         **extra: Any,
@@ -1315,6 +1329,8 @@ class App:
         type: Union[JobType, str],
         callbacks: Sequence[JobCallbackProtocol] = ...,
         system: Optional[SystemType] = ...,
+        gpus: Optional[int] = ...,
+        gpus_per_node: Optional[int] = ...,
         timeout: Optional[int] = ...,
         retries: int = ...,
         **extra: Any,
@@ -1327,6 +1343,8 @@ class App:
         type: Optional[Union[JobType, str]] = None,
         callbacks: Sequence[JobCallbackProtocol] = (),
         system: Optional[SystemType] = None,
+        gpus: Optional[int] = None,
+        gpus_per_node: Optional[int] = None,
         timeout: Optional[int] = None,
         retries: int = 0,
         **extra: Any,
@@ -1344,23 +1362,16 @@ class App:
                 pass it alongside keyword options).
             callbacks: Lifecycle callbacks from :mod:`simulo.callbacks`, recorded
                 into the package manifest and honored at execution.
-            system: The GPU system tier to request, as a
-                :class:`simulo.SystemType` member (e.g.
-                ``simulo.SystemType.TIER_1``), recorded in the job's resource
-                spec as ``resources["system"]`` (the tier's wire value, e.g.
-                ``"tier1"``). Validated HERE, at decoration time, against the
-                published catalog: a value that is not a ``SystemType`` member
-                (a raw string such as ``"tier1"`` included) raises
-                ``TypeError``, and a tier the platform cannot provision yet
-                raises ``ValueError``. ``simulo systems`` lists every tier and
-                which are available today. The selection is recorded on the
-                job AND scheduled against: the control plane filters a tiered
-                worker's claim to its own tier plus untiered work, so the tier
-                decides which GPU model runs the job. It is not a priority
-                setting. ``simulo systems`` reports this package's catalog,
-                not which tiers your platform has deployed. Naming a tier it
-                has no fleet for is refused when you submit, and the error
-                names the tiers it does have.
+            system: Accelerator memory class as a :class:`simulo.SystemType` member.
+                Omitted means Tier 1 (16 GB). Tier 2 is 24 GB, Tier 3 is 48 GB,
+                and Tier 4 is 96 GB per accelerator. Hardware within a class can
+                change. The built-in catalog enables Tier 1 and Tier 2 only;
+                the server must also check its fleet readiness at submission.
+            gpus: Total GPU count, a positive integer. Omitted means one GPU.
+                Today's built-in policy permits one GPU per job.
+            gpus_per_node: Optional positive integer layout constraint. All GPUs
+                must run on one machine, so this must equal the total GPU count.
+                It never multiplies ``gpus``. Counts reject booleans.
             timeout: Requested runtime limit for one managed execution, in
                 seconds (a positive integer; validated HERE, at decoration
                 time — a zero, negative, or non-integer value raises
@@ -1385,7 +1396,7 @@ class App:
             ValueError: ``timeout`` is not ``None`` and is not a positive
                 integer. ``True`` and ``False`` are not accepted as timeouts.
                 Also raised when ``system`` names a tier the platform cannot
-                provision yet (``SYSTEM_SPECS[system].available`` is false).
+                provision, or a GPU count/layout is unsupported by the built-in policy.
             JobDeclarationError: ``produces=`` or ``consumes=`` was passed. Outputs are
                 not declared on the decorator. Callbacks declare their own
                 supported outputs. Return small JSON values from the job, or use a named
@@ -1427,28 +1438,12 @@ class App:
                 "@app.job(system=simulo.SystemType.TIER_1). Run `simulo systems` to list the "
                 "tiers and which are available today. Remove gpu=."
             )
-        if system is not None:
-            # Static lookups against the published catalog — no fleet state
-            # is consulted. A raw string is refused even when it spells a
-            # valid wire value, so the one accepted spelling is the enum.
-            if not isinstance(system, SystemType):
-                raise JobDeclarationError(
-                    "@app.job(system=...) must be a simulo.SystemType member, e.g. "
-                    f"system=simulo.SystemType.TIER_1; got {system!r}. Run `simulo systems` to "
-                    "list the tiers."
-                )
-            spec = SYSTEM_SPECS[system]
-            if not spec.available:
-                available = ", ".join(
-                    f"SystemType.{tier.name} ({entry.gpu_model})"
-                    for tier, entry in SYSTEM_SPECS.items()
-                    if entry.available
-                )
-                raise ValueError(
-                    f"@app.job(system=SystemType.{system.name}) ({spec.gpu_model}) is not available on "
-                    f"the platform yet. Available today: {available}. Run `simulo systems` for the "
-                    "full catalog."
-                )
+        if system is not None and not isinstance(system, SystemType):
+            raise JobDeclarationError(
+                "@app.job(system=...) must be a simulo.SystemType member, e.g. "
+                f"system=simulo.SystemType.TIER_1; got {system!r}. Run `simulo systems` to list the tiers."
+            )
+        requested_resources = validate_resources(system, gpus, gpus_per_node)
 
         def decorate(func: F) -> JobFunction:
             location = Path(func.__code__.co_filename).name
@@ -1466,9 +1461,7 @@ class App:
                     f"{location}: Job {func.__name__!r} has invalid type={type!r}. Valid job types: {valid}. "
                     'Example: @app.job(type="train").'
                 ) from None
-            resources: dict[str, Any] = {}
-            if system is not None:
-                resources["system"] = system.value
+            resources = dict(requested_resources)
             resources.update(extra)
             policy_params = [
                 name

{simulo-0.34.0 → simulo-0.35.0}/src/simulo/_client/asset.py

@@ -1,7 +1,7 @@
 """``Asset`` — a read-only, registry-resolved mount (implements ``AssetProtocol``).
 
 A registry asset ref is ``[<publisher>/]<kind>/<name>[:v<N>]`` (e.g.
-``robot/so-arm-100:v3``, ``simulo/world/warehouse:v2``, or the unpinned
+``robot/so-arm-100:v3``, ``simulo/world/warehouse:v3``, or the unpinned
 ``robot/forklift`` — resolved to an exact version **at submit**). The grammar
 is the ONE shared parser from ``simulo.interfaces.platform.asset_catalog`` — the
 CLI, the control plane, the worker, and the console all parse through it, so the
@@ -148,7 +148,7 @@ class Asset:
     """A read-only, registry-resolved resource mounted into running jobs.
 
     A registry ref is ``[<publisher>/]<kind>/<name>[:v<N>]`` (e.g.
-    ``simulo/robot/cartpole:v1``); :meth:`from_registry` names one, and :attr:`path`
+    ``simulo/robot/cartpole:v5``); :meth:`from_registry` names one, and :attr:`path`
     resolves to its read-only mount inside a running job. ``Asset`` is also how a
     task names USD/URDF model sources to load into a scene — :meth:`usd` /
     :meth:`urdf`.

{simulo-0.34.0 → simulo-0.35.0}/src/simulo/_client/asset_pins.py

@@ -24,14 +24,33 @@ from typing import Any, Dict, List, Mapping, Optional, Sequence, TextIO
 
 from simulo._client.runtime_display import display_runtime
 from simulo._client.submit_api import AssetPinError, SubmitApiClient
-from simulo.interfaces.platform.asset_catalog import DEFAULT_ASSET_RUNTIME, ResolvedAssetPin, parse_asset_ref
+from simulo.interfaces.platform.asset_catalog import (
+    DEFAULT_ASSET_RUNTIME,
+    ResolvedAssetPin,
+    parse_asset_ref,
+)
+from simulo.interfaces.platform.runtimes import RUNTIME_ID_BY_ASSET_RUNTIME
 
 #: Re-exported from ``simulo.interfaces.platform.asset_catalog`` (current code and tests
 #: "Runtime-string seam", 2026-07-17 — hoisted there so the CLIENT's resolve
 #: request and the VALIDATOR's finalize call can never send different runtime
 #: strings). Kept as a module attribute here too — existing call sites
 #: (``app.py``, tests) import it from this module.
-__all__ = ["DEFAULT_ASSET_RUNTIME", "collect_asset_refs", "resolve_and_pin_assets"]
+__all__ = ["DEFAULT_ASSET_RUNTIME", "asset_runtime_for_runtime_id", "collect_asset_refs", "resolve_and_pin_assets"]
+
+
+def asset_runtime_for_runtime_id(runtime_id: str) -> str:
+    """Return the catalog label published for a requested job runtime.
+
+    Asset validation records catalog labels while manifests request job runtime
+    identifiers. There is no safe label for an unlisted runtime: resolving an
+    asset under Isaac would make the validation result describe a different
+    runtime from the job that will mount it.
+    """
+    for asset_runtime, mapped_runtime_id in RUNTIME_ID_BY_ASSET_RUNTIME.items():
+        if runtime_id == mapped_runtime_id:
+            return asset_runtime
+    raise AssetPinError(f"runtime {runtime_id!r} has no published asset catalog mapping")
 
 
 def collect_asset_refs(manifest: Mapping[str, Any]) -> List[str]:

{simulo-0.34.0 → simulo-0.35.0}/src/simulo/_client/cli.py

@@ -41,14 +41,12 @@ wheel's own bundled resources.
 saved sign-in state; a failed clone is removed before it can appear at that path.
 
 ``simulo systems [--json]`` lists the published GPU system tiers (``SystemType`` /
-``SYSTEM_SPECS`` from ``simulo-interfaces``) that ``@app.job(system=...)`` accepts —
+``SYSTEM_TIERS`` from ``simulo-interfaces``) that ``@app.job(system=...)`` accepts —
 table or ``--json``. This reads only that static, in-package catalog: no client
-construction, no credential resolution, no network call. The listing is descriptive
-rather than a live capability check: it reports what the catalog publishes, not which
-tiers this platform has actually deployed, and the table's own footer says so. The
-requested tier IS scheduled against — ``jobs/repo.py``'s claim predicate filters a
-tiered worker to its own tier plus untiered work — so this listing is not a
-record-only surface.
+construction, no credential resolution, no network call. It shows each tier's memory
+class, enabled GPU models, and static planning estimates for enabled tiers. It is not a
+live fleet or price check; the server can apply additional deployment checks when a job
+is submitted.
 
 **Auth** (``simulo login`` / ``logout`` / ``whoami``) drives the OAuth 2.0 +
 PKCE loopback flow and manages
@@ -108,6 +106,8 @@ import os
 import sys
 from typing import Optional, Sequence
 
+from simulo._client import http
+
 
 def _resolve_version() -> str:
     """Resolve the installed ``simulo`` distribution version for ``--version``.
@@ -209,6 +209,9 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
             # interpreter shutdown, where a closed reader fails outside any handler.
             sys.stdout.flush()
             sys.stderr.flush()
+    except (http.InsecureTransportError, http.InsecureBearerError) as exc:
+        print(f"error: {_safe_cli_error_text(exc)}", file=sys.stderr)
+        return 1
     except KeyboardInterrupt:
         # Last-resort safety net: every dispatched command already has its own
         # clean handling (``_observe_handler`` for the observe verbs,

{simulo-0.34.0 → simulo-0.35.0}/src/simulo/_client/cli_rendering.py

@@ -170,6 +170,16 @@ def _relative_time(value: Any) -> str:
     return f"on {_short_date(value)}"
 
 
+def _runtime_limit_text(runtime_budget_s: int) -> str:
+    """Render an exact server-resolved runtime budget in a compact unit."""
+    if runtime_budget_s % 60 == 0:
+        quantity = runtime_budget_s // 60
+        unit = "minute" if quantity == 1 else "minutes"
+        return f"{quantity} {unit}"
+    unit = "second" if runtime_budget_s == 1 else "seconds"
+    return f"{runtime_budget_s} {unit}"
+
+
 def _print_table(headers: tuple[str, ...], rows: Sequence[tuple[str, ...]]) -> None:
     """The compact whitespace-aligned table used by CLI list commands
     already render — factored out here as a shared helper for the newer

simulo-0.35.0/src/simulo/_client/cli_runtime_limit.py

@@ -0,0 +1,130 @@
+"""Best-effort runtime guidance based on a saved source job's measured progress."""
+
+from __future__ import annotations
+
+import math
+import shlex
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Optional
+
+from simulo._client import http, preview_report
+from simulo._client._runner import JobHandle
+from simulo._client.cli_rendering import _runtime_limit_text
+from simulo._client.jobs_api import JobsApiClient
+from simulo._client.policies_api import PoliciesApiClient
+from simulo.interfaces.ids import parse_checkpoint_ref, policy_id_for_job
+from simulo.interfaces.platform.runs import JOB_SCOPE_ORG
+
+
+@dataclass(frozen=True)
+class CheckpointProgress:
+    iteration: int
+    iterations_per_minute: Optional[float] = None
+
+
+def _checkpoint(client: PoliciesApiClient, ref: str) -> tuple[dict[str, Any], dict[str, Any]]:
+    policy_id, kind = parse_checkpoint_ref(ref)
+    policy = client.get_policy(str(policy_id))
+    checkpoints = policy.get("checkpoints")
+    if isinstance(checkpoints, list):
+        for checkpoint in checkpoints:
+            if isinstance(checkpoint, dict) and checkpoint.get("kind") == kind:
+                return policy, checkpoint
+    return policy, {}
+
+
+def checkpoint_progress(handle: JobHandle, ref: str, *, measure_rate: bool = False) -> Optional[CheckpointProgress]:
+    """Read the selected checkpoint once; unavailable measurements leave submission intact."""
+    assert handle.base_url is not None
+    client = PoliciesApiClient(handle.base_url, token=handle.token)
+    progress: Optional[CheckpointProgress] = None
+    try:
+        policy, checkpoint = _checkpoint(client, ref)
+        iteration = checkpoint.get("iteration")
+        if type(iteration) is not int or iteration < 0:
+            return None
+        progress = CheckpointProgress(iteration)
+        if not measure_rate or not isinstance(policy.get("job_public_id"), str):
+            return progress
+        source = JobsApiClient(handle.base_url, token=handle.token).get_job(
+            policy["job_public_id"], scope=JOB_SCOPE_ORG
+        )
+        return CheckpointProgress(iteration, _source_rate(client, source, checkpoint))
+    except (ValueError, http.HttpError):
+        return progress
+
+
+def _timestamp(value: Any) -> Optional[datetime]:
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return parsed if parsed.tzinfo is not None else None
+
+
+def _source_rate(client: PoliciesApiClient, source: dict[str, Any], checkpoint: dict[str, Any]) -> Optional[float]:
+    """Retries and unresolved starting checkpoints cannot give a reliable single-job rate."""
+    if source.get("attempts", 1) != 1:
+        return None
+    started, saved = _timestamp(source.get("started_at")), _timestamp(checkpoint.get("updated_at"))
+    if started is None or saved is None or saved <= started:
+        return None
+    start_iteration = 0
+    if source.get("input_checkpoint"):
+        _, starting_checkpoint = _checkpoint(client, source["input_checkpoint"])
+        candidate = starting_checkpoint.get("iteration")
+        if type(candidate) is not int or candidate < 0:
+            return None
+        start_iteration = candidate
+    iterations = checkpoint["iteration"] - start_iteration
+    return iterations * 60 / (saved - started).total_seconds() if iterations > 0 else None
+
+
+def runtime_limit_lines(handle: JobHandle, progress: Optional[CheckpointProgress]) -> list[str]:
+    """Estimate remaining iterations only when both a target and measured rate are known."""
+    budget = handle.runtime_budget_s
+    if budget is None:
+        return []
+    lines = [
+        f"Runtime limit: {_runtime_limit_text(budget)}. "
+        "The platform uses the lower of your organization's cap and any @app.job(timeout=...) limit. "
+        f"To raise your organization's cap, email {preview_report.SUPPORT_EMAIL}."
+    ]
+    total = handle.job_args.get("max_iterations")
+    if (
+        progress is None
+        or progress.iterations_per_minute is None
+        or type(total) is not int
+        or total <= progress.iteration
+    ):
+        return lines
+    minutes = (total - progress.iteration) / progress.iterations_per_minute
+    lines.append(
+        f"Estimated remaining training time: {_runtime_limit_text(math.ceil(minutes) * 60)} "
+        f"at the source job's rate of {progress.iterations_per_minute:.3g} iterations/min. "
+        "Measured from source job start to checkpoint save; startup time can differ."
+    )
+    if minutes * 60 > budget:
+        lines.append("Warning: the requested iterations are unlikely to finish within the runtime limit.")
+    return lines
+
+
+def runtime_recovery_lines(client: JobsApiClient, handle: JobHandle, app_path: str) -> list[str]:
+    """A failed follow still reports its outcome if this best-effort read fails."""
+    job_ref = str(handle.public_id or handle.job_id)
+    try:
+        record = client.get_job(job_ref)
+    except http.HttpError:
+        return []
+    if record.get("status") != "timed_out" or record.get("status_reason") != "org_runtime_limit_exceeded":
+        return []
+    checkpoint = f"{policy_id_for_job(job_ref)}:latest"
+    return [
+        "Runtime limit reached.",
+        f"Check for a saved checkpoint: simulo policy get {checkpoint}",
+        f"To continue, use simulo run {shlex.quote(app_path)} --from {checkpoint} "
+        "with the original training arguments and a higher --max-iterations total.",
+    ]