icmd-python 3.3.5__py3-none-any.whl → 3.11.0__py3-none-any.whl

icmd/__init__.py

@@ -6,14 +6,20 @@ from .core.advisory import AdvisoryFinding, ContractProvider, check_input_dict
 from .core.contracts import ContractClient, ContractTransport
 from .core.exceptions import (
     ICMDAuthenticationError,
+    ICMDChecksumMismatchError,
     ICMDConnectionError,
     ICMDContractUnavailableError,
+    ICMDMissingDependencyError,
+    ICMDModelMigrationError,
     ICMDRefreshNetworkError,
     ICMDRefreshRateLimitedError,
     ICMDRefreshResponseError,
     ICMDRefreshTokenInvalidError,
     ICMDRefreshUnavailableError,
+    ICMDReleaseRefusedError,
     ICMDRequestError,
+    ICMDResultsChangedError,
+    ICMDResultsRefusedError,
     ICMDTokenRefreshError,
     ICMDValidationError,
 )
@@ -83,14 +89,20 @@ __all__ = [
     "GridSampling",
     "GridVariable",
     "ICMDAuthenticationError",
+    "ICMDChecksumMismatchError",
     "ICMDConnectionError",
     "ICMDContractUnavailableError",
+    "ICMDMissingDependencyError",
+    "ICMDModelMigrationError",
     "ICMDRefreshNetworkError",
     "ICMDRefreshRateLimitedError",
     "ICMDRefreshResponseError",
     "ICMDRefreshTokenInvalidError",
     "ICMDRefreshUnavailableError",
+    "ICMDReleaseRefusedError",
     "ICMDRequestError",
+    "ICMDResultsChangedError",
+    "ICMDResultsRefusedError",
     "ICMDTokenRefreshError",
     "ICMDValidationError",
     "LatinHypercubeSampling",

icmd/_vendor/assembler.py

@@ -23,7 +23,9 @@ __all__ = [
     "build_design_document",
 ]
 
-#: The scenario discriminator this assembler emits into ``qt_model_inputs``.
+#: The scenario discriminator inside ``qt_model_inputs``.  A catalog node
+#: carries ``qt_model.scenario_key`` instead and the backend derives this from
+#: it; a trained-model node, whose scenarios have no key, still carries it.
 #: Exported so consumers that must recognize it -- notably the advisory check,
 #: which excludes it from contract validation -- bind to this module rather than
 #: re-spelling the literal.  Renaming it here must not leave a stale copy behind.
@@ -83,23 +85,29 @@ def assemble_model_inputs(inputs: Mapping[str, Any]) -> list[dict[str, Any]]:
 
 
 def assemble_model_node(
-    name: str,
+    key: str,
     model_uuid: str,
     inputs: Mapping[str, Any],
-    scenario: str | None = None,
+    scenario_key: str | None = None,
     node_id: str | None = None,
 ) -> dict[str, Any]:
     """Build one model workflow node without model lookup or validation.
 
-    ``node_id`` identifies this workflow instance. The catalog ``model_uuid``
-    remains in ``qt_model.uuid`` and is used only as the default node id.
+    The node is identified by ``qt_model.key`` and ``qt_model.scenario_key``.
+    The backend derives the ``__meta_scenario`` title from the scenario key, so
+    a discriminator in *inputs* is dropped when one is given rather than sent
+    as a second, possibly stale, answer. ``node_id`` identifies this workflow
+    instance. The catalog ``model_uuid`` remains in ``qt_model.uuid`` and is
+    used only as the default node id.
     """
     model_inputs = deepcopy(dict(inputs))
-    if scenario is not None:
-        model_inputs[SCENARIO_KEY] = {"title": scenario}
+    qt_model = {"key": key, "uuid": model_uuid}
+    if scenario_key is not None:
+        qt_model["scenario_key"] = scenario_key
+        model_inputs.pop(SCENARIO_KEY, None)
     return {
         "id": model_uuid if node_id is None else node_id,
-        "qt_model": {"name": name, "uuid": model_uuid},
+        "qt_model": qt_model,
         "qt_model_inputs": assemble_model_inputs(model_inputs),
     }
 

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,13 +275,15 @@ 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
         ----------
         name : str
-            The action's ``url_path`` (e.g. ``"resubmit"``,
+            The action's ``url_path`` (e.g. ``"submit-draft"``,
             ``"queue-position"``, ``"save-calibration"``).
         uuid : str | None
             When given, the action is detail-scoped to this resource UUID.
@@ -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")