dominus-sdk-python 6.1.3__tar.gz → 6.3.0__tar.gz

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 6.1.3
+Version: 6.3.0
 Summary: Python SDK for the Dominus gateway-first platform
 Author-email: CareBridge Systems <dev@carebridge.io>
 License-Expression: LicenseRef-Proprietary

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/dominus/__init__.py

@@ -160,12 +160,19 @@ from .errors import (
     ValidationError,
     ConflictError,
     ServiceError,
+    StashBookmarkArtifactNotFound,
+    StashBookmarkInvalidVersionRef,
+    StashBookmarkDuplicateName,
+    StashBookmarkUpstreamRejected,
+    StashWatchInvalidWebhookUrl,
+    StashWatchUpstreamRejected,
+    StashWatchNotFound,
     SecureTableError,
     ConnectionError as DominusConnectionError,
     TimeoutError as DominusTimeoutError,
 )
 
-__version__ = "6.1.3"
+__version__ = "6.3.0"
 __all__ = [
     # Main SDK instance
     "dominus",
@@ -250,6 +257,13 @@ __all__ = [
     "ValidationError",
     "ConflictError",
     "ServiceError",
+    "StashBookmarkArtifactNotFound",
+    "StashBookmarkInvalidVersionRef",
+    "StashBookmarkDuplicateName",
+    "StashBookmarkUpstreamRejected",
+    "StashWatchInvalidWebhookUrl",
+    "StashWatchUpstreamRejected",
+    "StashWatchNotFound",
     "SecureTableError",
     "DominusConnectionError",
     "DominusTimeoutError",

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/dominus/errors.py

@@ -205,6 +205,34 @@ class ServiceError(DominusError):
         super().__init__(message, status_code, details, endpoint)
 
 
+class StashBookmarkArtifactNotFound(NotFoundError):
+    """Raised when a stash artifact bookmark target cannot be found."""
+
+
+class StashBookmarkInvalidVersionRef(ValidationError):
+    """Raised when a stash artifact bookmark version_ref is invalid."""
+
+
+class StashBookmarkDuplicateName(ConflictError):
+    """Raised when a stash artifact bookmark name is already in use."""
+
+
+class StashBookmarkUpstreamRejected(ServiceError):
+    """Raised when the artifact backend rejects a stash bookmark operation."""
+
+
+class StashWatchInvalidWebhookUrl(ValidationError):
+    """Raised when a stash artifact watcher webhook_url is invalid."""
+
+
+class StashWatchUpstreamRejected(ServiceError):
+    """Raised when the artifact backend rejects a stash watch operation."""
+
+
+class StashWatchNotFound(NotFoundError):
+    """Raised when a stash artifact watcher cannot be found."""
+
+
 class ConnectionError(DominusError):
     """Raised when connection to the backend fails."""
 
@@ -244,6 +272,17 @@ class SecureTableError(DominusError):
         super().__init__(message, status_code, details, endpoint)
 
 
+STASH_ERROR_CLASSES = {
+    "stash.bookmark.artifact_not_found": StashBookmarkArtifactNotFound,
+    "stash.bookmark.invalid_version_ref": StashBookmarkInvalidVersionRef,
+    "stash.bookmark.duplicate_name": StashBookmarkDuplicateName,
+    "stash.bookmark.upstream_rejected": StashBookmarkUpstreamRejected,
+    "stash.watch.invalid_webhook_url": StashWatchInvalidWebhookUrl,
+    "stash.watch.upstream_rejected": StashWatchUpstreamRejected,
+    "stash.watch.not_found": StashWatchNotFound,
+}
+
+
 def raise_for_status(
     status_code: int,
     message: str,
@@ -262,6 +301,7 @@ def raise_for_status(
     Raises:
         Appropriate DominusError subclass
     """
+    code = _first_string((details or {}).get("code"))
     error_classes = {
         400: ValidationError,
         401: AuthenticationError,
@@ -274,5 +314,5 @@ def raise_for_status(
         504: TimeoutError,
     }
 
-    error_class = error_classes.get(status_code, DominusError)
+    error_class = STASH_ERROR_CLASSES.get(code) or error_classes.get(status_code, DominusError)
     raise error_class(message, status_code, details, endpoint)

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/dominus/namespaces/authority.py

@@ -1155,6 +1155,7 @@ class AuthorityNamespace:
         until: Optional[str] = None,
         window_hours: Optional[int] = None,
         limit: Optional[int] = None,
+        full: bool = False,
         timeout: Optional[float] = None,
     ) -> Dict[str, Any]:
         """
@@ -1172,6 +1173,7 @@ class AuthorityNamespace:
             "until": until,
             "window_hours": window_hours,
             "limit": limit,
+            "full": 1 if full else None,
         })
         return await self._get(
             f"/api/authority/dossiers/deploy/{quote(deploy_id, safe='')}{qs}",

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/dominus/namespaces/recipes.py

@@ -12,16 +12,76 @@ Refs follow ``recipe://{type}/{name}[@v{N}][?tier={tier}]``.
 """
 from __future__ import annotations
 
+import json
 from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ..start import Dominus
 
 
+STASH_BACKED_RECIPE_TYPES = frozenset({
+    "envoy-bootstrap-v1",
+    "envoy-release-publish-v1",
+    "envoy-policy-v1",
+    "pacs-extraction-recipe-v1",
+    "pacs-vendor-probe-v1",
+    "browser-recipe",
+})
+
+
 def _compact(payload: Dict[str, Any]) -> Dict[str, Any]:
     return {k: v for k, v in payload.items() if v is not None and v != ""}
 
 
+def _recipe_tier_to_stash_scope(tier: Optional[str]) -> str:
+    if tier == "platform":
+        return "platform"
+    if tier == "group":
+        return "group"
+    return "self"
+
+
+def _resolve_recipe_stash_env(client: "Dominus", env: Optional[str]) -> str:
+    return env or getattr(client, "_gateway_env", None) or "production"
+
+
+def _recipe_body_to_text(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    if value is None:
+        raise ValueError("body is required")
+    return json.dumps(value, separators=(",", ":"))
+
+
+def _build_recipe_payload_from_stash(
+    *,
+    type: str,
+    name: str,
+    tier: Optional[str],
+    data: Dict[str, Any],
+) -> Dict[str, Any]:
+    version = data.get("version")
+    try:
+        version_int = int(version) if version is not None else None
+    except (TypeError, ValueError):
+        version_int = None
+    return {
+        "recipe": {
+            "metadata": {
+                "type": type,
+                "name": name,
+                "tier": data.get("resolved_tier") or tier,
+                "version": version_int,
+                "schema_version": 1,
+                "sha256": data.get("value_hash"),
+                "head_ref": data.get("head_ref"),
+                "snapshot_ref": data.get("snapshot_ref"),
+            },
+            "body": data.get("value"),
+        },
+    }
+
+
 class RecipesNamespace:
     """
     Recipe worker namespace.
@@ -86,16 +146,41 @@ class RecipesNamespace:
         body: str,
         description: Optional[str] = None,
         actor_context: Optional[Dict[str, str]] = None,
+        env: Optional[str] = None,
         timeout: float = 30.0,
     ) -> Dict[str, Any]:
-        """Publish a recipe. ``POST /api/recipe/recipes/publish``."""
+        """Publish a recipe. Stash-backed recipe types accept optional ``env``."""
+        body_text = _recipe_body_to_text(body)
+        if type in STASH_BACKED_RECIPE_TYPES:
+            result = await self._client._request(
+                endpoint="/svc/stash/put",
+                method="POST",
+                body={
+                    "env": _resolve_recipe_stash_env(self._client, env),
+                    "kind": type,
+                    "scope": _recipe_tier_to_stash_scope(tier),
+                    "key": name,
+                    "value": body_text,
+                    "versioned": True,
+                    "purpose": description or "sdk-recipe-publish",
+                },
+                use_gateway=True,
+                actor=actor_context,
+                timeout=timeout,
+            )
+            return _build_recipe_payload_from_stash(
+                type=type,
+                name=name,
+                tier=tier,
+                data=result,
+            )
         return await self._post(
             "/api/recipe/recipes/publish",
             _compact({
                 "type": type,
                 "tier": tier,
                 "name": name,
-                "body": body,
+                "body": body_text,
                 "description": description,
             }),
             actor_context=actor_context,
@@ -167,9 +252,30 @@ class RecipesNamespace:
         name: str,
         version: Optional[int] = None,
         tier: Optional[str] = None,
+        env: Optional[str] = None,
         timeout: float = 15.0,
     ) -> Dict[str, Any]:
-        """Resolve a recipe through the three-tier chain. ``GET /api/recipe/recipes/{type}/{name}[@v{N}]``."""
+        """Resolve a recipe. Stash-backed recipe types accept optional ``env``."""
+        if type in STASH_BACKED_RECIPE_TYPES:
+            result = await self._client._request(
+                endpoint="/svc/stash/get",
+                method="POST",
+                body={
+                    "env": _resolve_recipe_stash_env(self._client, env),
+                    "kind": type,
+                    "scope": _recipe_tier_to_stash_scope(tier),
+                    "key": name,
+                    "version": version if version is not None else "head",
+                },
+                use_gateway=True,
+                timeout=timeout,
+            )
+            return _build_recipe_payload_from_stash(
+                type=type,
+                name=name,
+                tier=tier,
+                data=result,
+            )
         path = f"/api/recipe/recipes/{type}/{name}"
         if version is not None:
             path += f"@v{version}"

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/dominus/namespaces/stash.py

@@ -6,10 +6,18 @@ stores items in each project's ``stash.*`` schema and transparently falls
 back to a designated shared project on read.
 """
 from typing import Any, Dict, List, Optional, TYPE_CHECKING
+from urllib.parse import urlencode
 
 if TYPE_CHECKING:
     from ..start import Dominus
 
+BookmarkRef = Dict[str, Any]
+WatcherRef = Dict[str, Any]
+
+
+def _facade_query(*, env: str, kind: str, scope: str, key: str) -> str:
+    return urlencode({"env": env, "kind": kind, "scope": scope, "key": key})
+
 
 class StashNamespace:
     """
@@ -273,3 +281,155 @@ class StashNamespace:
             body=body,
             use_gateway=True,
         )
+
+    async def bookmark(
+        self,
+        *,
+        env: str,
+        kind: str,
+        scope: str,
+        key: str,
+        name: str,
+        version_ref: str,
+        timeout: float = 30.0,
+    ) -> BookmarkRef:
+        """Create or update a named bookmark for a stash artifact facade item."""
+        return await self._client._request(
+            endpoint="/svc/stash/bookmark",
+            method="POST",
+            body={
+                "env": env,
+                "kind": kind,
+                "scope": scope,
+                "key": key,
+                "name": name,
+                "version_ref": version_ref,
+            },
+            use_gateway=True,
+            timeout=timeout,
+        )
+
+    async def unbookmark(
+        self,
+        *,
+        env: str,
+        kind: str,
+        scope: str,
+        key: str,
+        name: str,
+        timeout: float = 30.0,
+    ) -> None:
+        """Remove a named bookmark from a stash artifact facade item."""
+        await self._client._request(
+            endpoint="/svc/stash/unbookmark",
+            method="POST",
+            body={
+                "env": env,
+                "kind": kind,
+                "scope": scope,
+                "key": key,
+                "name": name,
+            },
+            use_gateway=True,
+            timeout=timeout,
+        )
+        return None
+
+    async def watch(
+        self,
+        *,
+        env: str,
+        kind: str,
+        scope: str,
+        key: str,
+        watcher_name: str,
+        webhook_url: str,
+        timeout: float = 30.0,
+    ) -> WatcherRef:
+        """Create or update a webhook watcher for a stash artifact facade item."""
+        return await self._client._request(
+            endpoint="/svc/stash/watch",
+            method="POST",
+            body={
+                "env": env,
+                "kind": kind,
+                "scope": scope,
+                "key": key,
+                "watcher_name": watcher_name,
+                "webhook_url": webhook_url,
+            },
+            use_gateway=True,
+            timeout=timeout,
+        )
+
+    async def unwatch(
+        self,
+        *,
+        env: str,
+        kind: str,
+        scope: str,
+        key: str,
+        watcher_name: str,
+        timeout: float = 30.0,
+    ) -> None:
+        """Remove a webhook watcher from a stash artifact facade item."""
+        await self._client._request(
+            endpoint="/svc/stash/unwatch",
+            method="POST",
+            body={
+                "env": env,
+                "kind": kind,
+                "scope": scope,
+                "key": key,
+                "watcher_name": watcher_name,
+            },
+            use_gateway=True,
+            timeout=timeout,
+        )
+        return None
+
+    async def list_bookmarks(
+        self,
+        *,
+        env: str,
+        kind: str,
+        scope: str,
+        key: str,
+        timeout: float = 30.0,
+    ) -> List[BookmarkRef]:
+        """List bookmark refs for a stash artifact facade item."""
+        result = await self._client._request(
+            endpoint=f"/svc/stash/bookmark/list?{_facade_query(env=env, kind=kind, scope=scope, key=key)}",
+            method="GET",
+            use_gateway=True,
+            timeout=timeout,
+        )
+        if isinstance(result, list):
+            return result
+        if isinstance(result, dict):
+            bookmarks = result.get("bookmarks")
+            return bookmarks if isinstance(bookmarks, list) else []
+        return []
+
+    async def list_watchers(
+        self,
+        *,
+        env: str,
+        kind: str,
+        scope: str,
+        key: str,
+        timeout: float = 30.0,
+    ) -> List[WatcherRef]:
+        """List watcher refs for a stash artifact facade item."""
+        result = await self._client._request(
+            endpoint=f"/svc/stash/watch/list?{_facade_query(env=env, kind=kind, scope=scope, key=key)}",
+            method="GET",
+            use_gateway=True,
+            timeout=timeout,
+        )
+        if isinstance(result, list):
+            return result
+        if isinstance(result, dict):
+            watchers = result.get("watchers")
+            return watchers if isinstance(watchers, list) else []
+        return []

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/dominus_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 6.1.3
+Version: 6.3.0
 Summary: Python SDK for the Dominus gateway-first platform
 Author-email: CareBridge Systems <dev@carebridge.io>
 License-Expression: LicenseRef-Proprietary

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/dominus_sdk_python.egg-info/SOURCES.txt

@@ -61,6 +61,8 @@ tests/test_provisioning_parity.py
 tests/test_public_exports.py
 tests/test_publisher_namespace.py
 tests/test_recipes_namespace.py
+tests/test_recipes_stash_routing.py
+tests/test_stash_artifact_facade.py
 tests/test_transport_compat.py
 tests/test_workflow_lifecycle.py
 tests/test_workflow_refs.py

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dominus-sdk-python"
-version = "6.1.3"
+version = "6.3.0"
 description = "Python SDK for the Dominus gateway-first platform"
 readme = "README.md"
 license = "LicenseRef-Proprietary"

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/tests/test_authority_public_vocabulary.py

@@ -217,6 +217,7 @@ async def test_authority_scope_methods_use_canonical_context_wire_names():
         until="2026-04-11T09:33:00Z",
         window_hours=24,
         limit=150,
+        full=True,
     )
     await namespace.query_timelines(
         subject="PCM47474562",
@@ -314,7 +315,7 @@ async def test_authority_scope_methods_use_canonical_context_wire_names():
     )
     assert client.calls[7]["endpoint"] == (
         "/api/authority/dossiers/deploy/deploy-1?"
-        "since=2026-04-11T08%3A33%3A00Z&until=2026-04-11T09%3A33%3A00Z&window_hours=24&limit=150"
+        "since=2026-04-11T08%3A33%3A00Z&until=2026-04-11T09%3A33%3A00Z&window_hours=24&limit=150&full=1"
     )
     assert client.calls[8]["body"] == {
         "subject": "PCM47474562",

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.3.0}/tests/test_recipes_namespace.py

@@ -61,7 +61,7 @@ async def test_recipes_namespace_passes_actor_context_on_publish(monkeypatch, sd
 
     actor = {"type": "user", "id": "user-1"}
     await sdk.recipes.publish(
-        type="browser-recipe",
+        type="legacy-recipe-type",
         tier="project",
         name="cms-login",
         body="version: browser-recipe-v1\nsteps: []\n",
@@ -73,7 +73,7 @@ async def test_recipes_namespace_passes_actor_context_on_publish(monkeypatch, sd
             "endpoint": "/api/recipe/recipes/publish",
             "method": "POST",
             "body": {
-                "type": "browser-recipe",
+                "type": "legacy-recipe-type",
                 "tier": "project",
                 "name": "cms-login",
                 "body": "version: browser-recipe-v1\nsteps: []\n",