icmd-python 3.10.0__py3-none-any.whl → 3.14.0__py3-none-any.whl

icmd/__init__.py

@@ -22,6 +22,7 @@ from .core.exceptions import (
     ICMDResultsRefusedError,
     ICMDTokenRefreshError,
     ICMDValidationError,
+    ICMDVersionError,
 )
 from .core.model_classes import ContractFallbackWarning
 from .links import KIND_PATHS, link_for
@@ -105,6 +106,7 @@ __all__ = [
     "ICMDResultsRefusedError",
     "ICMDTokenRefreshError",
     "ICMDValidationError",
+    "ICMDVersionError",
     "LatinHypercubeSampling",
     "ModelInput",
     "ModelNode",

icmd/_vendor/assembler.py

@@ -113,7 +113,7 @@ def assemble_model_node(
 
 
 def build_design_document(
-    composition: Mapping[str, Any],
+    composition: Mapping[str, Any] | None,
     variables: Mapping[str, Any] | None = None,
     databases: Sequence[Mapping[str, Any]] | None = None,
     engine: str | None = None,
@@ -126,6 +126,12 @@ def build_design_document(
     all, so an empty one is left out rather than written present-and-falsy.
     Passing ``[]`` or ``""`` is therefore the same as passing nothing, and the
     advisory reports the deferring model either way.
+
+    ``composition`` follows the same rule, for the "none" composition mode a
+    design uses when its models do not need thermodynamics. The key must be
+    absent rather than empty: an empty mapping reads downstream as a
+    composition that happens to have no components, which is a different claim.
+    The envelope schema does not require the key.
     """
     design_space = deepcopy(dict(variables)) if variables is not None else {}
     design_space.setdefault("sampling_input", {"type": "grid"})
@@ -133,7 +139,9 @@ def build_design_document(
     design_space.setdefault("model_variables", [])
     design_space.setdefault("dataset_variables", [])
     design_space.setdefault("series_dataset_variables", [])
-    document: dict[str, Any] = {"composition": deepcopy(dict(composition))}
+    document: dict[str, Any] = {}
+    if composition:
+        document["composition"] = deepcopy(dict(composition))
     if databases:
         document["databases"] = deepcopy(list(databases))
     if engine:

icmd/apps/__init__.py

@@ -11,6 +11,7 @@ Provides a clean nested-attribute API::
 
 from .account import AccountApp
 from .agent import AgentApp
+from .comments import CommentsApp
 from .constants import ProjectKind
 from .studio import StudioApp
 from .suite import SuiteApp
@@ -19,6 +20,7 @@ from .workspace import WorkspaceApp
 __all__ = [
     "AccountApp",
     "AgentApp",
+    "CommentsApp",
     "ProjectKind",
     "StudioApp",
     "SuiteApp",

icmd/apps/agent.py

@@ -55,7 +55,11 @@ def _poll_message(
     elapsed = 0
     while True:
         msg = _expect_dict(
-            client.request_json("get", f"{_MESSAGE_PATH}/{message_uuid}", inject_group=False),
+            client.request_json(
+                "get",
+                f"{_MESSAGE_PATH}/{message_uuid}",
+                inject_group=client.has_owner_group,
+            ),
             _MESSAGE_PATH,
         )
         if (msg.get("status") or "").lower() in _TERMINAL_MESSAGE_STATUSES:

icmd/apps/base.py

@@ -214,7 +214,7 @@ class ReadOnlyResource:
         uuid: str,
         *,
         params: dict[str, Any] | None = None,
-        inject_group: bool = False,
+        inject_group: bool | None = None,
     ) -> dict:
         """Get a single resource by UUID.
 
@@ -223,21 +223,26 @@ class ReadOnlyResource:
         caller's server-side ``current_group`` (whatever they last
         selected in the web UI).  A resource owned by any other group
         answers ``404`` — this is not a cross-group lookup, and omitting
-        ``owner_group`` does not make it one.  For jobs specifically, the
-        Studio action ``studio/jobs/{uuid}/accessible-group/`` answers which
-        of your groups can ordinarily see a job; it walks plain project
-        access, so it performs no admin widening.
+        ``owner_group`` does not make it one.  By default the client's group
+        is sent when it already holds one (see :attr:`ICMD.has_owner_group`),
+        so a resource created through this client is found again.  For jobs
+        specifically, the Studio action ``studio/jobs/{uuid}/accessible-group/``
+        answers which of your groups can ordinarily see a job; it walks plain
+        project access, so it performs no admin widening.
 
         Parameters
         ----------
         uuid : str
             The resource UUID.
         params : dict | None
-            Query parameters, forwarded only when not ``None``.
-        inject_group : bool
-            When ``True``, pin the lookup to the client's active
-            ``owner_group`` (resolving it if needed) instead of leaving it
-            to the caller's ``current_group``.
+            Query parameters, forwarded only when not ``None``.  An
+            ``owner_group`` named here is sent as given.
+        inject_group : bool | None
+            ``None`` (default) pins the lookup to the client's
+            ``owner_group`` only when the client already holds one, and never
+            resolves or prompts for one.  ``True`` always pins, resolving the
+            group if needed; ``False`` never pins, leaving the lookup to the
+            caller's ``current_group``.
 
         Returns
         -------
@@ -245,6 +250,8 @@ class ReadOnlyResource:
             The resource record.
         """
         endpoint = f"{self._path}/{uuid}"
+        if inject_group is None:
+            inject_group = self._client.has_owner_group
         kwargs: dict[str, Any] = {"inject_group": inject_group}
         if params is not None:
             kwargs["params"] = params
@@ -268,8 +275,10 @@ class ReadOnlyResource:
         *method*.
 
         The active ``owner_group`` is injected as a query parameter for
-        *list* actions (no *uuid*) and skipped for *detail* actions — the
-        same convention :meth:`list` and :meth:`get` follow.
+        *list* actions (no *uuid*); *detail* actions send it only when the
+        client already holds one — the same convention :meth:`list` and
+        :meth:`get` follow.  An ``owner_group`` named in *params* is sent as
+        given either way.
 
         Parameters
         ----------
@@ -292,7 +301,7 @@ class ReadOnlyResource:
             list, some a single object).
         """
         endpoint = "/".join(part for part in (self._path, uuid, name) if part)
-        kwargs: dict[str, Any] = {"inject_group": uuid is None}
+        kwargs: dict[str, Any] = {"inject_group": uuid is None or self._client.has_owner_group}
         if data is not None:
             kwargs["json"] = data
         if params is not None:
@@ -328,8 +337,8 @@ class Resource(ReadOnlyResource):
         supported across the API — several viewsets accept ``PATCH`` but
         block ``PUT`` to keep their state-machine guards intact (e.g.
         studio jobs, suite ML models).  Use :meth:`replace` for a full
-        ``PUT`` replacement where the resource allows it.  Group injection
-        is skipped — the UUID fully identifies the target.
+        ``PUT`` replacement where the resource allows it.  Like :meth:`get`,
+        the request is pinned to the client's group only when it holds one.
 
         Parameters
         ----------
@@ -345,7 +354,9 @@ class Resource(ReadOnlyResource):
         """
         endpoint = f"{self._path}/{uuid}"
         return _expect_dict(
-            self._client.request_json("patch", endpoint, inject_group=False, json=data),
+            self._client.request_json(
+                "patch", endpoint, inject_group=self._client.has_owner_group, json=data
+            ),
             endpoint,
         )
 
@@ -369,7 +380,9 @@ class Resource(ReadOnlyResource):
         """
         endpoint = f"{self._path}/{uuid}"
         return _expect_dict(
-            self._client.request_json("put", endpoint, inject_group=False, json=data),
+            self._client.request_json(
+                "put", endpoint, inject_group=self._client.has_owner_group, json=data
+            ),
             endpoint,
         )
 
@@ -399,7 +412,9 @@ class Resource(ReadOnlyResource):
         """
         endpoint = f"{self._path}/{uuid}"
         return _expect_dict(
-            self._client.request_json("delete", endpoint, inject_group=False),
+            self._client.request_json(
+                "delete", endpoint, inject_group=self._client.has_owner_group
+            ),
             endpoint,
         )
 
@@ -435,7 +450,8 @@ class SoftDeleteMixin:
         """
         endpoint = f"{self._path}/{uuid}/trash"
         return _expect_dict(
-            self._client.request_json("post", endpoint, inject_group=False), endpoint
+            self._client.request_json("post", endpoint, inject_group=self._client.has_owner_group),
+            endpoint,
         )
 
     def restore(self, uuid: str) -> dict:
@@ -453,7 +469,8 @@ class SoftDeleteMixin:
         """
         endpoint = f"{self._path}/{uuid}/restore"
         return _expect_dict(
-            self._client.request_json("post", endpoint, inject_group=False), endpoint
+            self._client.request_json("post", endpoint, inject_group=self._client.has_owner_group),
+            endpoint,
         )
 
     def permanent_delete(self, uuid: str, *, confirm: bool = False) -> dict:
@@ -483,7 +500,10 @@ class SoftDeleteMixin:
             )
         endpoint = f"{self._path}/{uuid}/permanent-delete"
         return _expect_dict(
-            self._client.request_json("delete", endpoint, inject_group=False), endpoint
+            self._client.request_json(
+                "delete", endpoint, inject_group=self._client.has_owner_group
+            ),
+            endpoint,
         )
 
 

icmd/apps/comments.py

@@ -0,0 +1,34 @@
+"""Discussion comments and your comment notifications (``/api/v2/comments/``).
+
+A discussion belongs to one item (a job, dataset, composition, ...), named by
+``target_type`` and ``target_id``.  Listing needs both, and a new comment
+carries them in its body::
+
+    icmd = ICMD("icmd.ai")
+    on_job = {"target_type": "job", "target_id": "<uuid>"}
+    icmd.comments.comment.list(**on_job)
+    icmd.comments.comment.add({**on_job, "body": "Looks good"})
+
+A comment's ``delete`` is final: nothing restores it.  Notifications are the
+caller's own feed, list-only; mark them read through
+``icmd.comments.notification.action("mark_all_read", method="post")``.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .base import ReadOnlyResource, Resource
+
+if TYPE_CHECKING:
+    from icmd.core.session import ResourceClient
+
+
+class CommentsApp:
+    """Discussion comments and comment notifications."""
+
+    __slots__ = ("comment", "notification")
+
+    def __init__(self, client: ResourceClient) -> None:
+        self.comment = Resource(client, "comments")
+        self.notification = ReadOnlyResource(client, "comments/notifications")

icmd/apps/jobs.py

@@ -620,14 +620,16 @@ class JobResource(ReadOnlyResource):
         """Get the current status of a job (``GET /jobs/{uuid}/status/``)."""
         endpoint = f"{self._path}/{uuid}/status"
         return _expect_dict(
-            self._client.request_json("get", endpoint, inject_group=False), endpoint
+            self._client.request_json("get", endpoint, inject_group=self._client.has_owner_group),
+            endpoint,
         )
 
     def cancel(self, uuid: str) -> dict:
         """Cancel a running job (``POST /jobs/{uuid}/cancel/``)."""
         endpoint = f"{self._path}/{uuid}/cancel"
         return _expect_dict(
-            self._client.request_json("post", endpoint, inject_group=False), endpoint
+            self._client.request_json("post", endpoint, inject_group=self._client.has_owner_group),
+            endpoint,
         )
 
     def check_status(self, uuid: str) -> tuple[str, dict]:
@@ -671,7 +673,9 @@ class JobResource(ReadOnlyResource):
         if from_timestamp is not None:
             params["from_timestamp"] = from_timestamp
         return _expect_dict(  # type: ignore[return-value]
-            self._client.request_json("get", endpoint, inject_group=False, params=params or None),
+            self._client.request_json(
+                "get", endpoint, inject_group=self._client.has_owner_group, params=params or None
+            ),
             endpoint,
         )
 
@@ -690,7 +694,9 @@ class JobResource(ReadOnlyResource):
         """
         endpoint = f"{self._path}/{uuid}/log-entries"
         return _expect_dict(
-            self._client.request_json("get", endpoint, inject_group=False, params=params or None),
+            self._client.request_json(
+                "get", endpoint, inject_group=self._client.has_owner_group, params=params or None
+            ),
             endpoint,
         )
 
@@ -845,7 +851,9 @@ class JobResource(ReadOnlyResource):
         """
         endpoint = f"{self._path}/{uuid}"
         return _expect_dict(
-            self._client.request_json("delete", endpoint, inject_group=False),
+            self._client.request_json(
+                "delete", endpoint, inject_group=self._client.has_owner_group
+            ),
             endpoint,
         )
 
@@ -869,7 +877,9 @@ class JobResource(ReadOnlyResource):
             )
         endpoint = f"{self._path}/{uuid}/permanent-delete"
         return _expect_dict(
-            self._client.request_json("delete", endpoint, inject_group=False),
+            self._client.request_json(
+                "delete", endpoint, inject_group=self._client.has_owner_group
+            ),
             endpoint,
         )
 
@@ -1530,7 +1540,7 @@ class JobResource(ReadOnlyResource):
             self._client.request_json(
                 "post",
                 f"{self._path}/{uuid}/attach-plot",
-                inject_group=False,
+                inject_group=self._client.has_owner_group,
                 data={"source": json.dumps(transfer._plot_header(source), allow_nan=False)},
                 **transfer._figure_part(figure),
             ),

icmd/apps/results.py

@@ -228,7 +228,9 @@ class ResultsResource(ReadOnlyResource):
         dict
             The result record.
         """
-        return self.get(uuid, params={"admin": "true"} if admin else None, inject_group=admin)
+        return self.get(
+            uuid, params={"admin": "true"} if admin else None, inject_group=True if admin else None
+        )
 
     def grant(
         self,

icmd/cli/__init__.py

@@ -17,6 +17,7 @@ from icmd.core.exceptions import (
     ICMDConnectionError,
     ICMDRequestError,
     ICMDValidationError,
+    ICMDVersionError,
 )
 from icmd.core.session import normalize_domain
 from icmd.version import __version__
@@ -54,6 +55,7 @@ class _ICMDGroup(click.Group):
             ICMDValidationError,
             ICMDConnectionError,
             ICMDRequestError,
+            ICMDVersionError,
         ) as exc:
             name = type(exc).__name__.removeprefix("ICMD")
             # A throttled refresh names its own wait; publish it as a field so

icmd/cli/commands.py

@@ -370,10 +370,9 @@ _DETAIL_ROUTE_CAUSES = (
     "a project you cannot reach",
 )
 
-#: What ``log`` — and ``action --id`` when ``--param`` carried no
-#: ``owner_group`` — must say about scope: both call
-#: ``request_json(..., inject_group=False)``, so naming a group here would name
-#: one the client never transmitted.
+#: What a detail command's 404 says about scope when it sent no group.  The CLI
+#: client holds a group only for an explicit ``--group``; without one, naming a
+#: group here would name one the client never transmitted.
 _NO_GROUP_SENT = (
     "none was sent, so the server used your current_group — whatever you last "
     "selected in the web UI"
@@ -978,11 +977,12 @@ def _make_permanent_delete_cmd(path: str) -> click.Command:
 
 
 #: The two halves of a detail action's scope, each offered on a 404 only when
-#: ``--param`` did not already carry it: telling callers to re-run the flag
-#: they just typed is the wild-goose chase :func:`_explaining_404` exists to end.
+#: the call did not already send it (through ``--param``, or ``--group`` for the
+#: group): telling callers to re-run the flag they just typed is the
+#: wild-goose chase :func:`_explaining_404` exists to end.
 _ACTION_GROUP_REMEDY = (
-    "Add --param owner_group=<id> to scope the call explicitly — action sends "
-    "no group on a detail route."
+    "Add --group <name|id> or --param owner_group=<id> to scope the call "
+    "explicitly — without either, action sends no group on a detail route."
 )
 _ACTION_ADMIN_REMEDY = (
     "Add --param admin=true where the route honours it: it resolves the id as "
@@ -1013,6 +1013,7 @@ def _action_explanation(  # noqa: PLR0913 — each input decides a part of the m
     uuid: str | None,
     method: str,
     query: dict[str, str],
+    client: Any,
 ) -> contextlib.AbstractContextManager[None]:
     """Build the ``404`` annotation an ``action`` call runs under.
 
@@ -1021,10 +1022,13 @@ def _action_explanation(  # noqa: PLR0913 — each input decides a part of the m
     """
     if not uuid:
         return contextlib.nullcontext()
-    # ``action`` transmits no scope of its own, so ``--param`` is the whole
-    # truth about one: report the group the caller actually sent, and offer
-    # only the half they left out.
+    # Report the group the caller actually sent, and offer only the half they
+    # left out: ``--param owner_group`` wins, else the SDK pins the client's
+    # group, which the CLI holds only for an explicit ``--group``.
     sent_group = query.get("owner_group")
+    if "owner_group" not in query and client.has_owner_group:
+        held = client.owner_group
+        sent_group = f"{held['id']} ({held['name']})"
     remedies: tuple[str, ...] = ()
     if not sent_group:
         remedies += (_ACTION_GROUP_REMEDY,)
@@ -1040,6 +1044,14 @@ def _action_explanation(  # noqa: PLR0913 — each input decides a part of the m
     return _explaining_404(uuid, scope=scope, remedies=remedies, cause=_action_name_cause(name))
 
 
+#: ``action`` names that cannot be undone whatever their method, so they take
+#: ``--yes`` like a ``--method delete``.  The backend's MCP server confirms the
+#: same set, and its CLI parity test compares the two.
+IRREVERSIBLE_ACTIONS: frozenset[str] = frozenset(
+    {"permanent-delete", "empty-trash", "detach-plot", "transfer-ownership", "developer-access"}
+)
+
+
 def _make_action_cmd(path: str) -> click.Command:
     """Build a generic ``action`` command — the CLI escape hatch for custom actions.
 
@@ -1078,7 +1090,10 @@ def _make_action_cmd(path: str) -> click.Command:
         "assume_yes",
         is_flag=True,
         default=False,
-        help="Skip the confirmation prompt for a destructive (--method delete) action.",
+        help=(
+            "Skip the confirmation prompt for a destructive action: any --method delete, "
+            f"and {', '.join(sorted(IRREVERSIBLE_ACTIONS))}."
+        ),
     )
     @_global_options
     def action_cmd(**opts: Any) -> None:
@@ -1086,14 +1101,20 @@ def _make_action_cmd(path: str) -> click.Command:
         body, body_file = opts["body"], opts["body_file"]
         data = _load_json_body(body, body_file) if (body or body_file) else None
         query = _parse_param_pairs(opts["params"])
-        if opts["method"] == "delete":
-            target = "/".join(p for p in (path, opts["uuid"], opts["name"]) if p)
+        # Gate on the URL's last segment, not NAME: ``--id`` may carry the action itself.
+        target = "/".join(p for p in (path, opts["uuid"], opts["name"]) if p)
+        if (
+            opts["method"] == "delete"
+            or target.strip("/").rsplit("/", 1)[-1] in IRREVERSIBLE_ACTIONS
+        ):
             _confirm_destructive(
-                f"Run destructive action DELETE {target}? This may be irreversible.",
+                f"Run destructive action {opts['method'].upper()} {target}? "
+                "This may be irreversible.",
                 yes=opts["assume_yes"],
             )
         ctx = click.get_current_context()
-        resource = _get_client_and_resource(ctx, path)
+        client = _build_client(ctx)
+        resource = Resource(client, path)
         with _action_explanation(
             ctx,
             path=path,
@@ -1101,6 +1122,7 @@ def _make_action_cmd(path: str) -> click.Command:
             uuid=opts["uuid"],
             method=opts["method"],
             query=query,
+            client=client,
         ):
             result = resource.action(
                 opts["name"],
@@ -1232,23 +1254,31 @@ def _make_log_cmd(path: str) -> click.Command:
         client = _build_client(ctx)
         endpoint = f"{path}/{resource_id}/logs"
 
-        # ``action logs --id`` reaches this exact endpoint by construction, and
-        # unlike ``log`` it can carry an explicit scope through ``--param``.
-        remedy = (
-            f"`{ctx.parent.command_path} action logs --id {resource_id} "  # type: ignore[union-attr]
-            "--param owner_group=<id> --param admin=true` reaches the same "
-            "endpoint with an explicit scope — log sends neither."
-        )
         # ``log`` is declared on ``studio/jobs`` alone (``registry.py:149``), so
         # the ``accessible-group`` sentence needs no path check here.
-        remedies = (remedy, _accessible_group_remedy(ctx, resource_id))
-        with _explaining_404(resource_id, scope=_NO_GROUP_SENT, remedies=remedies):
+        # ``action logs --id`` reaches this exact endpoint by construction, and
+        # unlike ``log`` it can also send ``admin=true``.
+        action_logs = f"`{ctx.parent.command_path} action logs --id {resource_id}"  # type: ignore[union-attr]
+        if client.has_owner_group:
+            group = client.owner_group
+            scope = f"?owner_group={group['id']} ({group['name']}) was sent"
+            admin_remedy = (
+                f"{action_logs} --group <name|id> --param admin=true` reads them as a group admin."
+            )
+        else:
+            scope = f"{_NO_GROUP_SENT}; pass --group <name|id> to name one"
+            admin_remedy = (
+                f"{action_logs} --param owner_group=<id> --param admin=true` reaches "
+                "the same endpoint with an explicit scope — log sent neither."
+            )
+        remedies = (admin_remedy, _accessible_group_remedy(ctx, resource_id))
+        with _explaining_404(resource_id, scope=scope, remedies=remedies):
             if not follow:
                 params: dict[str, str] = {}
                 if from_timestamp is not None:
                     params["from_timestamp"] = from_timestamp
                 result = client.request_json(
-                    "get", endpoint, inject_group=False, params=params or None
+                    "get", endpoint, inject_group=client.has_owner_group, params=params or None
                 )
                 write_output(result, fmt=_format(ctx))
                 return
@@ -1274,7 +1304,9 @@ def _fetch_log_page(client: Any, endpoint: str, next_ts: str | None) -> dict[str
     params: dict[str, str] = {}
     if next_ts is not None:
         params["from_timestamp"] = next_ts
-    result = client.request_json("get", endpoint, inject_group=False, params=params or None)
+    result = client.request_json(
+        "get", endpoint, inject_group=client.has_owner_group, params=params or None
+    )
     if not isinstance(result, dict):
         raise click.ClickException(
             f"Unexpected log response from {endpoint}: expected dict, got {type(result).__name__}"

icmd/cli/registry.py

@@ -392,4 +392,28 @@ APP_REGISTRY: tuple[AppSpec, ...] = (
             ),
         ),
     ),
+    AppSpec(
+        "comments",
+        "Discussion comments and your comment notifications",
+        resources=(
+            # ``DELETE`` trashes a comment, but nothing restores it: ``hard``.
+            ResourceSpec(
+                "comment",
+                "comments",
+                writable=True,
+                delete_style="hard",
+                help=(
+                    "Comments on a job, dataset or other item "
+                    "(list needs --param target_type=job --param target_id=<uuid>)"
+                ),
+            ),
+            # Recipient-scoped and list-only: there is no detail ``GET``.
+            ResourceSpec(
+                "notification",
+                "comments/notifications",
+                actions=("list", "action"),
+                help="Your comment notifications (mark_read etc. via `action`)",
+            ),
+        ),
+    ),
 )

icmd/client.py

@@ -8,8 +8,9 @@ owner-group logic.
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
+from urllib.parse import urlsplit
 
-from .apps import AccountApp, AgentApp, StudioApp, SuiteApp, WorkspaceApp
+from .apps import AccountApp, AgentApp, CommentsApp, StudioApp, SuiteApp, WorkspaceApp
 from .apps.base import _expect_dict
 from .core.auth import Authenticator
 
@@ -24,13 +25,66 @@ from .core.auth import (
     detect_auth_method,
     display_banner,
 )
-from .core.constants import PUBLIC_CONFIG
+from .core.constants import MIN_ICMD_VERSION, PUBLIC_CONFIG
 from .core.contracts import ContractClient
 from .core.credentials import CredentialManager
-from .core.exceptions import ICMDRefreshTokenInvalidError, ICMDRequestError
+from .core.exceptions import ICMDRefreshTokenInvalidError, ICMDRequestError, ICMDVersionError
 from .core.groups import GroupManager
 from .core.session import Session, normalize_domain
 from .links import link_for
+from .version import __version__
+
+
+def _version_key(value: object) -> tuple[int, ...] | None:
+    """Return *value* as comparable integers, or ``None`` when it is not a release number.
+
+    Trailing zeros are dropped so ``20.61.0`` and ``20.61.0.0`` compare equal.
+    ``None`` (empty, a dev build, garbage) makes the caller skip that check.
+    """
+    if not isinstance(value, str):
+        return None
+    parts = value.strip().split(".")
+    if not all(part.isdecimal() for part in parts):
+        return None
+    key = [int(part) for part in parts]
+    while key and key[-1] == 0:
+        key.pop()
+    return tuple(key)
+
+
+def _check_compatibility(session: Session) -> None:
+    """Raise :class:`ICMDVersionError` when either side's minimum rules the other out.
+
+    The config is cached on the session, so the login banner reuses this fetch;
+    a failed one reads as ``{}`` and leaves connectivity to the login.
+    """
+    config = session.get_server_config()
+    domain = urlsplit(session.domain).netloc
+    site_version = config.get("ICMD_VERSION") or ""
+    paired = config.get("ICMD_PYTHON_VERSION") or ""
+    # Unauthenticated input shown as a copy-paste command: only a release number qualifies.
+    install = (
+        f'\nInstall the version released with it: pip install "icmd-python=={paired}"'
+        if _version_key(paired) is not None
+        else ""
+    )
+    installed = _version_key(__version__)
+    site = _version_key(site_version)
+
+    sdk_minimum = config.get("ICMD_PYTHON_MINIMUM")
+    minimum = _version_key(sdk_minimum)
+    if installed is not None and minimum is not None and installed < minimum:
+        runs = f"{domain} runs ICMD® {site_version}" if site is not None else domain
+        raise ICMDVersionError(
+            f"{runs}, which needs icmd-python {sdk_minimum} or newer; "
+            f"you have {__version__}.{install}"
+        )
+
+    if site is not None and site < (_version_key(MIN_ICMD_VERSION) or ()):
+        raise ICMDVersionError(
+            f"{domain} runs ICMD® {site_version}; icmd-python {__version__} needs "
+            f"ICMD® {MIN_ICMD_VERSION} or newer.{install}"
+        )
 
 
 class ICMD:
@@ -75,6 +129,10 @@ class ICMD:
             protocol.
         ICMDValidationError
             If *domain* is invalid.
+        ICMDVersionError
+            If the site serves a minimum SDK version above this one, or runs an
+            ICMD® release older than this SDK supports.  Raised before any
+            login prompt; a site that serves no version is not checked.
         ICMDTokenRefreshError
             If a cached session could not be renewed for a transient reason —
             a throttled (:class:`ICMDRefreshRateLimitedError`), unreachable, or
@@ -101,6 +159,7 @@ class ICMD:
             self._authenticator = (
                 NotebookAuthenticator() if _in_jupyter() else TerminalAuthenticator()
             )
+        _check_compatibility(self._session)
 
         if developer_token:
             self.auth_method: str = "DEVELOPER_TOKEN"
@@ -124,6 +183,7 @@ class ICMD:
         self.studio = StudioApp(self)
         self.workspace = WorkspaceApp(self)
         self.agent = AgentApp(self)
+        self.comments = CommentsApp(self)
         self.account = AccountApp(self)
 
     # -----------------------------------------------------------------
@@ -433,6 +493,16 @@ class ICMD:
         """Return the active owner group as a full group dict."""
         return self._groups.owner_group
 
+    @property
+    def has_owner_group(self) -> bool:
+        """Whether this client already holds an owner group.
+
+        Set by the ``owner_group`` constructor argument, by
+        :meth:`set_owner_group`, or by the first request that resolved one.
+        Reading it never resolves a group, so it never prompts.
+        """
+        return self._groups.has_owner_group
+
     # -----------------------------------------------------------------
     # Group management
     # -----------------------------------------------------------------
@@ -474,7 +544,8 @@ class ICMD:
         ----------
         inject_group : bool
             If ``True`` (default), automatically inject the active
-            ``owner_group`` as a query parameter.  ``False`` suppresses that
+            ``owner_group`` as a query parameter; an ``owner_group`` already
+            in ``params`` is sent as given.  ``False`` suppresses that
             injection: group-scoped detail routes then fall back to the
             caller's server-side ``current_group``, while other endpoints
             apply their own scoping.  It does not request a cross-group

icmd/compose.py

@@ -62,7 +62,7 @@ def _assemble_tuple(model: ModelInput) -> dict[str, Any]:
 
 
 def compose_input_dict(
-    composition: Mapping[str, Any] | Composition,
+    composition: Mapping[str, Any] | Composition | None,
     models: Iterable[ModelInput | ModelNode],
     variables: Mapping[str, Any] | Sequence[DesignVariable] | DesignSpace | None = None,
     *,
@@ -110,9 +110,15 @@ def compose_input_dict(
 
     Parameters
     ----------
-    composition : Mapping[str, Any] | Composition
+    composition : Mapping[str, Any] | Composition | None
         The design composition, as a wire mapping or a
-        :class:`~icmd.types.Composition`.
+        :class:`~icmd.types.Composition`.  ``None`` or an empty mapping emits no
+        ``composition`` key, for a design whose models do not use
+        thermodynamics -- the "none" composition mode, which the Fatigue studio
+        defaults to.  It stays a *required* positional argument, so spell that
+        case ``compose_input_dict(None, models)``; giving it a default would
+        mean defaulting ``models`` as well, and reordering the parameters would
+        break every positional caller.
     models : Iterable[ModelInput | ModelNode]
         The workflow's model instances, in either spelling described above.
     variables : Mapping[str, Any] | Sequence[DesignVariable] | DesignSpace | None

icmd/core/advisory.py

@@ -84,13 +84,17 @@ class ContractProvider(Protocol):
         """Return the ACL-filtered contract for *model_uuid*."""
         ...
 
+    def envelope(self) -> dict[str, Any]:
+        """Return the job-envelope JSON Schema the backend validates submissions against."""
+        ...
+
 
 class _ModelInput(TypedDict):
     """An assembled model node narrowed for advisory checking.
 
     ``name`` is the node's ``qt_model.key``, or its name when it carries no
     key.  ``uuid`` is ``None`` for a node that does not carry its catalog uuid.
-    Such a node still gets the envelope half of the check -- which reads the
+    Such a node still gets the globals half of the check -- which reads the
     document alone -- and forces the contract half to report itself skipped,
     because there is no uuid to fetch a contract with.
     """
@@ -315,19 +319,20 @@ def _validator_for(schema_key: str) -> Any:
     return _construct_validator(schema_key)
 
 
+def _schema_validator(schema: dict[str, Any]) -> Any:
+    """Return the cached validator for *schema*, without re-checking its meta-schema."""
+    return _validator_for(
+        json.dumps(schema, ensure_ascii=False, separators=(",", ":"), sort_keys=True)
+    )
+
+
 def _validation_errors(
     schema: dict[str, Any],
     model_input: dict[str, Any],
     location: tuple[str | int, ...],
 ) -> list[Any]:
     """Validate one model input without repeatedly checking its meta-schema."""
-    schema_key = json.dumps(
-        schema,
-        ensure_ascii=False,
-        separators=(",", ":"),
-        sort_keys=True,
-    )
-    validator = _validator_for(schema_key)
+    validator = _schema_validator(schema)
     return sorted(
         validator.iter_errors(model_input),
         key=lambda error: _json_path((*location, *error.absolute_path)),
@@ -356,6 +361,92 @@ def _skipped(reason: str) -> list[AdvisoryFinding]:
     return [_finding("", None, "$", f"check skipped: {reason}", "skipped")]
 
 
+def _named_at_submit(error: Any) -> bool:
+    """Whether *error* is the missing name of a key-composed model node.
+
+    The backend names a catalog node from its key at submit binding, before
+    its envelope gate, so a catalog node's missing name is not a refusal. A
+    trained-model node composed by key without a name is suppressed too, yet
+    refused at submit: the backend does not name it, and telling its uuid
+    from a catalog one would take a lookup this check does not make.
+    """
+    return (
+        error.validator == "required"
+        and error.message == "'name' is a required property"
+        and bool(error.absolute_path)
+        and error.absolute_path[-1] == "qt_model"
+        and isinstance(error.instance, dict)
+        and bool(error.instance.get("key"))
+    )
+
+
+def _envelope_error_findings(error: Any, definitions: dict[str, Any]) -> list[AdvisoryFinding]:
+    """Report one envelope error against the union branch the document selects.
+
+    Mirrors qt-designer's ``validate_envelope``: a discriminated union is read
+    through the branch its tag names, and ``X | None`` through ``X``, so a
+    sampling input without ``type`` reads as ``required`` at the sampling input
+    rather than "not valid under any of the given schemas".
+    """
+    location = _json_path(tuple(error.absolute_path))
+    branches = error.schema.get(error.validator) if error.validator in ("anyOf", "oneOf") else None
+    if not branches:
+        return [_finding("", None, location, error.message, str(error.validator))]
+    if "discriminator" in error.schema:
+        tag_name = error.schema["discriminator"]["propertyName"]
+        if not isinstance(error.instance, dict):
+            return []  # The union's own ``type: object`` reports it.
+        if tag_name not in error.instance:
+            message = f"{tag_name!r} is a required property"
+            return [_finding("", None, location, message, "required")]
+        tags = [
+            definitions[branch["$ref"].removeprefix("#/$defs/")]["properties"][tag_name]["const"]
+            for branch in branches
+        ]
+        tag = error.instance[tag_name]
+        if tag not in tags:
+            return [
+                _finding("", None, location, f"{tag_name} {tag!r} is not one of {tags}", "enum")
+            ]
+        selected = tags.index(tag)
+    else:
+        non_null = [index for index, branch in enumerate(branches) if branch != {"type": "null"}]
+        if error.instance is None or len(non_null) != 1:
+            return [_finding("", None, location, error.message, str(error.validator))]
+        selected = non_null[0]
+    return [
+        finding
+        for sub_error in error.context or []
+        if sub_error.relative_schema_path[0] == selected
+        for finding in _envelope_error_findings(sub_error, definitions)
+    ]
+
+
+def _envelope_findings(
+    input_dict: dict[str, Any],
+    contracts: ContractProvider,
+) -> list[AdvisoryFinding]:
+    """Validate the whole document against the served job envelope.
+
+    An envelope that cannot be fetched or applied is one ``skipped`` finding,
+    never an empty list: an unchecked envelope must not read as a valid one.
+    """
+    envelope = getattr(contracts, "envelope", None)
+    if envelope is None:
+        return _skipped("job envelope: this contract provider has no envelope()")
+    try:
+        schema = envelope()
+        definitions = schema.get("$defs", {})
+        return [
+            finding
+            for error in _schema_validator(schema).iter_errors(input_dict)
+            if not _named_at_submit(error)
+            for finding in _envelope_error_findings(error, definitions)
+        ]
+    except Exception as exc:
+        return _skipped(f"job envelope: {str(exc).strip() or type(exc).__name__}")
+
+
 def _canonical_global(key: str) -> str | None:
     """Name the global a ``use_global`` sitting under *key* resolves against.
 
@@ -564,30 +655,33 @@ def check_input_dict(
     input_dict: dict[str, Any],
     contracts: ContractProvider,
 ) -> list[AdvisoryFinding]:
-    """Check assembled per-model inputs and return non-blocking findings.
-
-    Two independent halves, reported in that order. The envelope check reads
-    the document alone: a model deferring to a global the job never defines is
-    reported here rather than failing worker-side once the job is claimed, and
-    needs no contract to say so. Contract validation is the other half, and if
-    any model's contract cannot be fetched it contributes one ``"check
-    skipped"`` finding instead of its own, so partial contract output cannot be
+    """Check an assembled job input and return non-blocking findings.
+
+    Three independent parts, reported in this order. The job envelope comes
+    first: the whole document against the schema the backend serves, or one
+    ``"check skipped"`` finding when that schema cannot be fetched. The globals
+    check reads the document alone: a model deferring to a global the job never
+    defines is reported here rather than failing worker-side once the job is
+    claimed. Contract validation is last, and if any model's contract cannot be
+    fetched it contributes one ``"check skipped"`` finding instead of its own,
+    placed ahead of the globals findings, so partial contract output cannot be
     mistaken for a complete check.
 
-    The envelope findings survive that skip -- a pre-contract or unreachable
+    No part's skip suppresses another's findings -- an old or unreachable
     backend is where a pre-submit warning is worth most -- so an incomplete
     check is recognized by a ``kind == "skipped"`` finding, never by an empty
-    result. A skip puts that finding first.
+    result.
     """
+    envelope_findings = _envelope_findings(input_dict, contracts)
     try:
         models = _model_inputs(input_dict)
         global_findings = [
             finding for model in models for finding in _global_findings(model, input_dict)
         ]
     except Exception as exc:
-        return _skipped(str(exc).strip() or type(exc).__name__)
+        return [*envelope_findings, *_skipped(str(exc).strip() or type(exc).__name__)]
 
     contract_findings, reason = _contract_findings(models, contracts)
     if reason is not None:
-        return [*_skipped(reason), *global_findings]
-    return [*global_findings, *contract_findings]
+        return [*envelope_findings, *_skipped(reason), *global_findings]
+    return [*envelope_findings, *global_findings, *contract_findings]

icmd/core/auth.py

@@ -495,14 +495,11 @@ def enhance_auth_error(
 def display_banner(session: Session, authenticator: Authenticator) -> None:
     """Display the server config's banner message, if there is one.
 
-    An authenticator may set ``displays_messages = False`` to opt out; that
-    suppresses the server-config fetch as well as the display.  Authenticators
-    that do not declare the optional flag display the banner.
+    An authenticator may set ``displays_messages = False`` to opt out of the
+    display.  Authenticators that do not declare the optional flag display the
+    banner.
     """
     try:
-        # Skips the fetch, not merely the display: this round-trip is made
-        # solely to render the banner, so an authenticator that discards
-        # messages would spend a request per process on output nobody sees.
         # Defaulting to True preserves banner display for authenticators that
         # do not declare the flag.  Inside the try because a declared property
         # may raise something other than AttributeError, which getattr's

icmd/core/constants.py

@@ -61,3 +61,12 @@ compare its ``contract_sha256`` to decide whether a refresh is warranted.
 
 # Public
 PUBLIC_CONFIG = "public/config"
+
+# Compatibility
+MIN_ICMD_VERSION = "20.49.0"
+"""Oldest ICMD® release this SDK supports; a site below it is refused on connect.
+
+20.49.0 is where the backend binds model nodes by key, which is the only form
+this SDK composes.  Raise it in the change that drops a fallback for an older
+backend.
+"""

icmd/core/contracts.py

@@ -67,8 +67,9 @@ class ContractClient:
     The cache key includes the current owner group, resolved on every call
     because callers may change groups after constructing
     :class:`~icmd.client.ICMD`.  Generated classes hang off the entry, so no
-    class outlives the group and the scenario set it was licensed by.  Both
-    caches are memory-only and :meth:`clear` drops them together.
+    class outlives the group and the scenario set it was licensed by.  All three
+    -- contracts, their classes and the job envelope schema (one per client,
+    not group-scoped) -- are memory-only and :meth:`clear` drops them together.
     """
 
     def __init__(
@@ -84,6 +85,7 @@ class ContractClient:
         self._ttl = ttl
         self._clock = clock
         self._cache: dict[tuple[str, Hashable, str], _CacheEntry] = {}
+        self._envelope: tuple[dict[str, Any], float] | None = None
 
     def _cache_key(self, model_uuid: str) -> tuple[str, Hashable, str]:
         """Build a key from domain, the live effective group, and model UUID."""
@@ -193,6 +195,45 @@ class ContractClient:
         """Return a model contract, re-fetching once the cached copy expires."""
         return deepcopy(self._entry(model_uuid).contract)
 
+    def envelope(self) -> dict[str, Any]:
+        """Return the job-envelope JSON Schema, re-fetching once the cached copy expires.
+
+        The schema comes from ``studio/input-dicts/schema/`` and is the one the
+        backend validates every submitted job document against. It is not
+        owner-group scoped, so one copy serves the whole client, on the same TTL
+        as contracts.
+
+        Raises
+        ------
+        ICMDRequestError
+            If the request fails or the body carries no schema object.
+        """
+        now = self._clock()
+        if self._envelope is not None and now - self._envelope[1] < self._ttl:
+            return deepcopy(self._envelope[0])
+        response = self._session.api_request("GET", "studio/input-dicts/schema/")
+        if response.status_code == HTTPStatus.NOT_FOUND:
+            raise ICMDRequestError(
+                "This ICMD® backend does not serve the job envelope schema (it predates it).",
+                status_code=response.status_code,
+            )
+        check_response(response, "fetch job envelope schema")
+        try:
+            body = response.json()
+        except ValueError as exc:
+            raise ICMDRequestError(
+                "Expected a JSON job envelope schema.",
+                status_code=response.status_code,
+            ) from exc
+        schema = body.get("schema") if isinstance(body, dict) else None
+        if not isinstance(schema, dict):
+            raise ICMDRequestError(
+                "Expected a job envelope schema object.",
+                status_code=response.status_code,
+            )
+        self._envelope = (schema, now)
+        return deepcopy(schema)
+
     def model_class(self, model_uuid: str, scenario: str | None = None) -> type[BaseModel]:
         """Return the pydantic input class one model scenario describes.
 
@@ -253,5 +294,6 @@ class ContractClient:
         return check_input_dict(input_dict, self)
 
     def clear(self) -> None:
-        """Clear cached contracts and the classes built from them."""
+        """Clear cached contracts, the classes built from them, and the envelope schema."""
         self._cache.clear()
+        self._envelope = None

icmd/core/exceptions.py

@@ -49,6 +49,15 @@ class ICMDConnectionError(Exception):
     """Raised when connection to ICMD® fails."""
 
 
+class ICMDVersionError(Exception):
+    """Raised when this SDK and the ICMD® site it connects to cannot work together.
+
+    Either side may refuse: the site serves the oldest SDK it supports, and the
+    SDK declares the oldest ICMD® release it supports.  The message names the
+    version to install when the site says which icmd-python it was released with.
+    """
+
+
 class ICMDValidationError(Exception):
     """Raised when input validation fails."""
 

icmd/core/groups.py

@@ -71,6 +71,11 @@ class GroupManager:
             self._owner_group = self._resolve_owner_group()
         return self._owner_group
 
+    @property
+    def has_owner_group(self) -> bool:
+        """Whether a group is already held, without resolving one."""
+        return self._owner_group is not None
+
     def set_owner_group(self, group: int | str | None = None) -> None:
         """Set the owner group for subsequent API operations.
 
@@ -123,13 +128,15 @@ class GroupManager:
     def inject_params(self, kwargs: dict[str, Any]) -> None:
         """Inject ``owner_group`` as a query parameter, resolving lazily if needed.
 
-        No recursion risk: :meth:`_resolve_owner_group` fetches groups via
-        ``Session.request_json`` directly, which does not call back into
-        this method.
+        An ``owner_group`` the caller already names in ``params`` is sent as
+        given, and no group is resolved for it.  The caller's dict is copied,
+        never mutated.  No recursion risk: :meth:`_resolve_owner_group`
+        fetches groups via ``Session.request_json`` directly, which does not
+        call back into this method.
         """
-        group = self.owner_group
-        params = kwargs.get("params") or {}
-        params["owner_group"] = group["id"]
+        params = dict(kwargs.get("params") or {})
+        if params.get("owner_group") is None:
+            params["owner_group"] = self.owner_group["id"]
         kwargs["params"] = params
 
     # -----------------------------------------------------------------

icmd/core/session.py

@@ -69,6 +69,11 @@ class ResourceClient(Protocol):
 
     contracts: ContractClient
 
+    @property
+    def has_owner_group(self) -> bool:
+        """Whether an owner group is already held, without resolving one."""
+        ...
+
     def request_json(
         self,
         method: HTTPMethod,

icmd/version.py

@@ -1 +1 @@
-__version__ = "3.10.0"
+__version__ = "3.14.0"

{icmd_python-3.10.0.dist-info → icmd_python-3.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icmd-python
-Version: 3.10.0
+Version: 3.14.0
 Summary: Python client app for ICMD®
 Author: QuesTek Innovations LLC
 License-Expression: LicenseRef-Proprietary
@@ -116,8 +116,8 @@ errors go to stderr.
 
 - `ICMD` — the client facade. Constructing it authenticates (interactive sign-in, a developer
   token, or a stored credential) and binds the session to one tenant.
-- `client.suite`, `client.studio`, `client.workspace`, `client.agent`, `client.account` — the API
-  areas. Most expose resource objects with a uniform surface: `list()` and `list_all()`, `get()`,
+- `client.suite`, `client.studio`, `client.workspace`, `client.agent`, `client.account`,
+  `client.comments` — the API areas. Most expose resource objects with a uniform surface: `list()` and `list_all()`, `get()`,
   and, where the endpoint allows it, `add()`, `update()`, and `delete()`.
 - `client.contracts` — model contracts fetched from the server, and the advisory check that reads
   a job input against them.

{icmd_python-3.10.0.dist-info → icmd_python-3.14.0.dist-info}/RECORD

@@ -1,52 +1,53 @@
-icmd/__init__.py,sha256=-2i4tJ69UAb547_LPnAVrglNc1ZRRTce5Ju2BoKzaDc,3109
-icmd/client.py,sha256=eXWJuoHX2cv7B30Vha5aCAOoR5nE-y8u4d2V0d-_SU4,22600
-icmd/compose.py,sha256=-xkfVsqvNejYnaxvddlidNpzLE1tZ59Qdj8DZq1yENQ,7089
+icmd/__init__.py,sha256=TME0_M-oG3U7-rrdQ4cLzcp7JvgBeP0BhjjiDOshbaY,3155
+icmd/client.py,sha256=F9qwRrC1cfEFTw0FZgI7PWXX0J_B-bzv0CXs2R_R5EM,25606
+icmd/compose.py,sha256=kl_-yYiVRfglpyNn782iuzg54-_55Rf3XJnkqSY_Zq0,7563
 icmd/links.py,sha256=I8v8_xhI6lbUwrMjIUcYYcqKUi2PIPm6zQ7mXYP9A5E,6827
 icmd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 icmd/types.py,sha256=af26gLTblS33vhlYdHLSPKY7Rm1shJDDOpzauCeOxAE,81323
-icmd/version.py,sha256=iKJAvc5i0UTDDSSefTGL0Tq-kWQ4S3OJJgvyaQfQNF8,23
+icmd/version.py,sha256=xtcy_5Xf21-Fg12NJ-BUaHz9wwW-QCIv0Ni0UXGxy0s,23
 icmd/_vendor/__init__.py,sha256=VFA4EQd2l76sxgkHPUpgzZavFF6kFdpq9v71AZsPIdQ,579
-icmd/_vendor/assembler.py,sha256=2KpvpIARfcM2H1mE3ajKT6ukaEnE5cKztSySpsSq8ZA,5776
-icmd/apps/__init__.py,sha256=ak2ch1UU-qaiyOT1eCdRwqSI0Avhzyw5DLkw-U2ivQQ,659
+icmd/_vendor/assembler.py,sha256=3mOONZyT_J2WOVs06xofoxv0nSjBgSfPFV3nj-sUZGw,6176
+icmd/apps/__init__.py,sha256=Bg6rR2Zt38OHdBBwGKBzSqbsDW8chVM9KwjZ4IGODXE,712
 icmd/apps/account.py,sha256=BWDO0Zysv0ygLVhbeIk82BjsvuDVb_vBdu6jqBPw3tc,14557
-icmd/apps/agent.py,sha256=MmWuH1sYqo-hOhNNuTwh930H_BFXs7oMP0QgyzaC0Iw,8387
-icmd/apps/base.py,sha256=SHqvtkHTxNIYRZMV2BMG-SVTWl_3iPm4WVINUbjmGN4,18983
+icmd/apps/agent.py,sha256=EasQ0ZHbBbqXauAcoSym-eK2TOFDbdd2XGJPnKYBx6k,8467
+icmd/apps/base.py,sha256=kyowDVglcXok90DiM4GuGEObusH1m86ZWbWKLiGT8Aw,19931
+icmd/apps/comments.py,sha256=gnsyQvUVkSix4nxRjqHr2Jpz69iDQmbMmOTM5IClmWQ,1152
 icmd/apps/constants.py,sha256=5xoIwFNGOaAp2cHAlVDlbzJ7ObQHYXJgVGMBfNLCHzI,757
 icmd/apps/documents.py,sha256=8_wFc7NLUFQMYZA5hqsciXniHECZEWS-egX_ni8F4LE,3720
-icmd/apps/jobs.py,sha256=ckjS8Uz2hVyTqsTPF14g7paKMHsaRg3jZ90lZLdTz-o,66924
+icmd/apps/jobs.py,sha256=-OFCJNgeBJGfuq4joA29NHDcP4ZMLSc24VYN3NonuRA,67231
 icmd/apps/navigation.py,sha256=mbEJG33Z-Nha5txvMpL63sT-UqsgFgZ-NMhTU7L7gI0,3738
-icmd/apps/results.py,sha256=9Bh6DaZ7oDxrKxWsZxSVCBxKFLYd_3dASTaYhAhR6iQ,18224
+icmd/apps/results.py,sha256=vXT3mVZSNn_to_zYw3tO_SMIc1YpKbYxjBd_aOizRHI,18264
 icmd/apps/results_store.py,sha256=19g6XQVBpKGLC3o1RU_Dn6IV83Qtaq3i1d41m5yBQf4,12439
 icmd/apps/studio.py,sha256=XN6gVCqkTzp7qH9I-UOhW7UJ2RfkGv60H-G7ulkR850,2419
 icmd/apps/suite.py,sha256=1XT8aKPn15W-bwBdOz-JV3Wrmr_JOKyrMEC6--ljj9A,3907
 icmd/apps/transfer.py,sha256=UVVEOmYynLzRtdTO6dbUBm6om6oHgmnspuKjACp0arE,36736
 icmd/apps/types.py,sha256=jOzykkXWj9e_lk805_ABCC-sWBwIpJGN3HEb2AyQ9vw,1290
 icmd/apps/workspace.py,sha256=BXCOLQo5BMu-okW2Ink8L_FPhU8r7OWy2jDsvilU3Oo,3055
-icmd/cli/__init__.py,sha256=mBpAlW1BCKglPzdDffTc4uLdr_2Ri7qnVC2I-Q9FjEA,7395
+icmd/cli/__init__.py,sha256=KiXdv_n5SOPqBxtTFQSnfqMf-T1ScxuOrbdkB_GUHp8,7447
 icmd/cli/account.py,sha256=equTAGWR3NCCMYEPTw4IZKHEtBEdGD8F4Pp8cfiSNoU,13859
 icmd/cli/auth.py,sha256=UFpEf-lLlkbphivgBfd9NxAEqHcCsPmEl-DXet-NStg,3317
 icmd/cli/auth_status.py,sha256=6wkI3Q0c-t8DBOfuPaN_xXEUcL9HLZm1jX4lQ76X3Ag,13505
 icmd/cli/client.py,sha256=3iToPSABFYWWUPn-uDVFAv9GoBWQXP04l2Id_aYgd64,2186
-icmd/cli/commands.py,sha256=srDoAMF5kiMxph0vUKpo1urRt7CEaH7Lgrb1TiksWmk,63707
+icmd/cli/commands.py,sha256=z_LngviZ5tcMJx-gmsFfllAYpxvhsNqNFra2aVDrQ9Q,65158
 icmd/cli/diagnostics.py,sha256=1fXgKmpUMA5U-_79AzZ0uSibFmDTK_CLCe91YhBnM8s,2747
 icmd/cli/domain.py,sha256=MiGzdKwKaOEvMshsPPJTmdBm7pCTjGM98MOg9RhAL_k,874
 icmd/cli/links.py,sha256=7CMhKUJ-qKQmk2I-KCdn6oF06cdCq0v5jQDGU7gEJ30,14039
 icmd/cli/output.py,sha256=-TKZ8fJYCUhh7qHRNAZyFYFaXcMDqm4NDR2qFfErg5A,1190
-icmd/cli/registry.py,sha256=zUMbuDXLYO442J54Ivns_exFxYRwjnefA3zMrd1vaG4,16697
+icmd/cli/registry.py,sha256=MEkqcu2b6ZjfmE2L2L062PxTjOTjlVEyYSycTv_tq30,17577
 icmd/core/__init__.py,sha256=45q0vlUao61rG6ugufGTRtoDeBTDcscU5dLAMluDSBA,225
-icmd/core/advisory.py,sha256=9zB2Ew5RKtwwDKTYF3nPYSuv5SnHCEthriYfTr6Tzko,22707
-icmd/core/auth.py,sha256=bG6eLbSkmyDWLyprx7NJMDwLTGsOIrsRdBZ3f6vz1vk,29480
-icmd/core/constants.py,sha256=P3a01sDt5WmGYqkp5hu4UqWbMgfp50o6rBV3q9jU4yA,2339
-icmd/core/contracts.py,sha256=uHybwSxBHV4l6M4ho4ECRKitXm4lMbBroFhGxim0V0I,10690
+icmd/core/advisory.py,sha256=gQqaPUfSNhUQFG61SPqaZQhd_7AfzPgw8lNXhwulZhc,26994
+icmd/core/auth.py,sha256=WRY2BStFYQqSnk__oEQTrAvbvVCHQdm_G2YYOcHL_jY,29207
+icmd/core/constants.py,sha256=sKSy5oRqUKztlesyjirMEGrA9FmR4Kz-uPrDE8rv33A,2638
+icmd/core/contracts.py,sha256=QXMpxiPBltaXFfGCJx4Y2d7tkRyjWAIBragSg_NucXE,12575
 icmd/core/credentials.py,sha256=39vyoFH1_MrzD9TpTh4FVPhWbrY5X35zGCS22KeTi_8,46835
 icmd/core/display.py,sha256=RkgJhr2Bfw3-ZjGvE100ddD6oyAAUUAJfBAy6DvX5ik,13060
-icmd/core/exceptions.py,sha256=Lv9zPMqZqZW8O-QqZ8AThF2u9xcGv-yfHWk1Vl6FKeA,12663
-icmd/core/groups.py,sha256=OFbQce42DLDK0rDAdMbh8H7imNPAkBJMl7o7tbKQ4Iw,7211
+icmd/core/exceptions.py,sha256=c88w5neJU7ohm5iEboA29jFaUfZ8EfrxmiO9rornTTw,13035
+icmd/core/groups.py,sha256=BEwpBEe60l_8HpnsIvLPC3EhLSXnv-qyo-OZIyP0sWI,7585
 icmd/core/model_classes.py,sha256=uuhJwh_AZ69eOp8SoWYo0MM5rNwA_a-vkxhrIwFasds,40372
-icmd/core/session.py,sha256=UmpcixYEhBYgDJyd0ijXKhCXTK426XzbNzTCzSDM9WM,60759
-icmd_python-3.10.0.dist-info/licenses/LICENSE,sha256=644lGvCmDFa5hQl6xdhaYk3o-1oWqPXAIiiQlvqeZdE,1028
-icmd_python-3.10.0.dist-info/METADATA,sha256=oZpNJbpbNkS1w1Jx46TR3p3x2KMeySULtmpFnIEX-lE,5339
-icmd_python-3.10.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-icmd_python-3.10.0.dist-info/entry_points.txt,sha256=CFX537PlyyPQL3Q_3TKUFeiiDSkOAboqaLEy9AIEwVU,39
-icmd_python-3.10.0.dist-info/top_level.txt,sha256=olzM6Z_QEwg7RrFVOnkgO0I2Ps2m7vhSqYQZYeiawcw,5
-icmd_python-3.10.0.dist-info/RECORD,,
+icmd/core/session.py,sha256=I3X0z2ZZm9H68NLnOOs4vS6sn4THWLNjvgUcBDJB5i8,60902
+icmd_python-3.14.0.dist-info/licenses/LICENSE,sha256=644lGvCmDFa5hQl6xdhaYk3o-1oWqPXAIiiQlvqeZdE,1028
+icmd_python-3.14.0.dist-info/METADATA,sha256=-ZmtyDRQTcleRU64XI03xSfBVISxKNI7D6BSQkeks9Q,5358
+icmd_python-3.14.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+icmd_python-3.14.0.dist-info/entry_points.txt,sha256=CFX537PlyyPQL3Q_3TKUFeiiDSkOAboqaLEy9AIEwVU,39
+icmd_python-3.14.0.dist-info/top_level.txt,sha256=olzM6Z_QEwg7RrFVOnkgO0I2Ps2m7vhSqYQZYeiawcw,5
+icmd_python-3.14.0.dist-info/RECORD,,

{icmd_python-3.10.0.dist-info → icmd_python-3.14.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py3-none-any