icmd-python 3.11.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/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/client.py

@@ -8,6 +8,7 @@ owner-group logic.
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
+from urllib.parse import urlsplit
 
 from .apps import AccountApp, AgentApp, CommentsApp, StudioApp, SuiteApp, WorkspaceApp
 from .apps.base import _expect_dict
@@ -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"

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/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icmd-python
-Version: 3.11.0
+Version: 3.14.0
 Summary: Python client app for ICMD®
 Author: QuesTek Innovations LLC
 License-Expression: LicenseRef-Proprietary

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

@@ -1,12 +1,12 @@
-icmd/__init__.py,sha256=-2i4tJ69UAb547_LPnAVrglNc1ZRRTce5Ju2BoKzaDc,3109
-icmd/client.py,sha256=0mHPuWCvfv-urlTRqOvjmaBwFNt09XR1nmr-4QSRk3Q,23098
-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=cpptu6yAKjujkKCECVRXYkw3SmUpyBiTvJvB3Mmcu5s,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/_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=EasQ0ZHbBbqXauAcoSym-eK2TOFDbdd2XGJPnKYBx6k,8467
@@ -23,7 +23,7 @@ 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
@@ -35,19 +35,19 @@ icmd/cli/links.py,sha256=7CMhKUJ-qKQmk2I-KCdn6oF06cdCq0v5jQDGU7gEJ30,14039
 icmd/cli/output.py,sha256=-TKZ8fJYCUhh7qHRNAZyFYFaXcMDqm4NDR2qFfErg5A,1190
 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/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=I3X0z2ZZm9H68NLnOOs4vS6sn4THWLNjvgUcBDJB5i8,60902
-icmd_python-3.11.0.dist-info/licenses/LICENSE,sha256=644lGvCmDFa5hQl6xdhaYk3o-1oWqPXAIiiQlvqeZdE,1028
-icmd_python-3.11.0.dist-info/METADATA,sha256=47PYNTfR1-9e39BnnlAHFJQSOOfoWcQy6r2OHGcs59c,5358
-icmd_python-3.11.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-icmd_python-3.11.0.dist-info/entry_points.txt,sha256=CFX537PlyyPQL3Q_3TKUFeiiDSkOAboqaLEy9AIEwVU,39
-icmd_python-3.11.0.dist-info/top_level.txt,sha256=olzM6Z_QEwg7RrFVOnkgO0I2Ps2m7vhSqYQZYeiawcw,5
-icmd_python-3.11.0.dist-info/RECORD,,
+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,,