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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 6.1.3
+Version: 6.2.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.2.0}/dominus/__init__.py

@@ -165,7 +165,7 @@ from .errors import (
     TimeoutError as DominusTimeoutError,
 )
 
-__version__ = "6.1.3"
+__version__ = "6.2.0"
 __all__ = [
     # Main SDK instance
     "dominus",

{dominus_sdk_python-6.1.3 → dominus_sdk_python-6.2.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.2.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.2.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.2.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.2.0}/dominus_sdk_python.egg-info/SOURCES.txt

@@ -61,6 +61,7 @@ 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_transport_compat.py
 tests/test_workflow_lifecycle.py
 tests/test_workflow_refs.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dominus-sdk-python"
-version = "6.1.3"
+version = "6.2.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.2.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.2.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",

dominus_sdk_python-6.2.0/tests/test_recipes_stash_routing.py

@@ -0,0 +1,229 @@
+import pytest
+
+import dominus.start as start_module
+
+
+@pytest.fixture()
+def sdk(monkeypatch):
+    monkeypatch.setattr(start_module, "_VALIDATION_ERROR", None)
+    monkeypatch.setattr(start_module, "_TOKEN", "a" * 64)
+    monkeypatch.setattr(start_module, "_VALIDATED", False)
+    monkeypatch.setattr(start_module, "_BASE_URL", "https://gateway.example")
+    monkeypatch.setattr(start_module, "_GATEWAY_URL", "https://gateway.example")
+    return start_module.Dominus()
+
+
+@pytest.mark.asyncio
+async def test_publish_stash_backed_type_routes_to_stash(monkeypatch, sdk):
+    calls = []
+
+    async def fake_request(**kwargs):
+        calls.append(kwargs)
+        return {
+            "version": 1,
+            "value": "channel: prod\n",
+            "value_hash": "abc123",
+            "resolved_tier": "platform",
+            "head_ref": "stash://envoy-bootstrap-v1/envoy-prod@head",
+            "snapshot_ref": "stash://envoy-bootstrap-v1/envoy-prod@v1",
+        }
+
+    monkeypatch.setattr(sdk, "_request", fake_request)
+
+    result = await sdk.recipes.publish(
+        type="envoy-bootstrap-v1",
+        tier="platform",
+        name="envoy-prod",
+        body="channel: prod\n",
+        description="publish bootstrap",
+        env="staging",
+    )
+
+    assert len(calls) == 1
+    assert calls[0]["endpoint"] == "/svc/stash/put"
+    assert calls[0]["method"] == "POST"
+    assert calls[0]["use_gateway"] is True
+    assert calls[0]["timeout"] == 30.0
+    assert calls[0]["body"] == {
+        "env": "staging",
+        "kind": "envoy-bootstrap-v1",
+        "scope": "platform",
+        "key": "envoy-prod",
+        "value": "channel: prod\n",
+        "versioned": True,
+        "purpose": "publish bootstrap",
+    }
+    assert result == {
+        "recipe": {
+            "metadata": {
+                "type": "envoy-bootstrap-v1",
+                "name": "envoy-prod",
+                "tier": "platform",
+                "version": 1,
+                "schema_version": 1,
+                "sha256": "abc123",
+                "head_ref": "stash://envoy-bootstrap-v1/envoy-prod@head",
+                "snapshot_ref": "stash://envoy-bootstrap-v1/envoy-prod@v1",
+            },
+            "body": "channel: prod\n",
+        }
+    }
+
+
+@pytest.mark.asyncio
+async def test_publish_non_stash_backed_type_keeps_legacy_path(monkeypatch, sdk):
+    calls = []
+
+    async def fake_request(**kwargs):
+        calls.append(kwargs)
+        return {"ok": True, "recipe": {"version": 7}}
+
+    monkeypatch.setattr(sdk, "_request", fake_request)
+
+    result = await sdk.recipes.publish(
+        type="some-unmigrated-type",
+        tier="group",
+        name="legacy-recipe",
+        body="steps: []\n",
+        env="staging",
+    )
+
+    assert result["recipe"]["version"] == 7
+    assert calls == [
+        {
+            "endpoint": "/api/recipe/recipes/publish",
+            "method": "POST",
+            "body": {
+                "type": "some-unmigrated-type",
+                "tier": "group",
+                "name": "legacy-recipe",
+                "body": "steps: []\n",
+            },
+            "use_gateway": True,
+            "timeout": 30.0,
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_get_stash_backed_type_routes_to_stash(monkeypatch, sdk):
+    calls = []
+
+    async def fake_request(**kwargs):
+        calls.append(kwargs)
+        return {
+            "version": "2",
+            "value": "operation: fetch\n",
+            "value_hash": "def456",
+            "resolved_tier": "group",
+            "head_ref": "stash://pacs-extraction-recipe-v1/fuji-x@head",
+            "snapshot_ref": "stash://pacs-extraction-recipe-v1/fuji-x@v2",
+        }
+
+    monkeypatch.setattr(sdk, "_request", fake_request)
+
+    result = await sdk.recipes.get(
+        type="pacs-extraction-recipe-v1",
+        name="fuji-x",
+        version=2,
+        tier="group",
+        env="development",
+    )
+
+    assert len(calls) == 1
+    assert calls[0] == {
+        "endpoint": "/svc/stash/get",
+        "method": "POST",
+        "body": {
+            "env": "development",
+            "kind": "pacs-extraction-recipe-v1",
+            "scope": "group",
+            "key": "fuji-x",
+            "version": 2,
+        },
+        "use_gateway": True,
+        "timeout": 15.0,
+    }
+    assert result == {
+        "recipe": {
+            "metadata": {
+                "type": "pacs-extraction-recipe-v1",
+                "name": "fuji-x",
+                "tier": "group",
+                "version": 2,
+                "schema_version": 1,
+                "sha256": "def456",
+                "head_ref": "stash://pacs-extraction-recipe-v1/fuji-x@head",
+                "snapshot_ref": "stash://pacs-extraction-recipe-v1/fuji-x@v2",
+            },
+            "body": "operation: fetch\n",
+        }
+    }
+
+
+@pytest.mark.asyncio
+async def test_get_non_stash_backed_type_keeps_legacy_path(monkeypatch, sdk):
+    calls = []
+
+    async def fake_request(**kwargs):
+        calls.append(kwargs)
+        return {"recipe": {"metadata": {"name": "y"}}}
+
+    monkeypatch.setattr(sdk, "_request", fake_request)
+
+    result = await sdk.recipes.get(type="other", name="y", env="staging")
+
+    assert result["recipe"]["metadata"]["name"] == "y"
+    assert calls == [
+        {
+            "endpoint": "/api/recipe/recipes/other/y",
+            "method": "GET",
+            "use_gateway": True,
+            "timeout": 15.0,
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_recipe_body_to_text_validation(monkeypatch, sdk):
+    calls = []
+
+    async def fake_request(**kwargs):
+        calls.append(kwargs)
+        return {
+            "version": len(calls),
+            "value": kwargs["body"]["value"],
+            "value_hash": f"hash-{len(calls)}",
+            "resolved_tier": "self",
+        }
+
+    monkeypatch.setattr(sdk, "_request", fake_request)
+
+    string_result = await sdk.recipes.publish(
+        type="browser-recipe",
+        tier="project",
+        name="string-body",
+        body="steps: []\n",
+    )
+    dict_result = await sdk.recipes.publish(
+        type="browser-recipe",
+        tier="project",
+        name="dict-body",
+        body={"steps": []},
+    )
+
+    assert calls[0]["body"]["env"] == "production"
+    assert calls[0]["body"]["value"] == "steps: []\n"
+    assert string_result["recipe"]["body"] == "steps: []\n"
+    assert calls[1]["body"]["value"] == '{"steps":[]}'
+    assert dict_result["recipe"]["body"] == '{"steps":[]}'
+
+    with pytest.raises(ValueError, match="body is required"):
+        await sdk.recipes.publish(
+            type="browser-recipe",
+            tier="project",
+            name="missing-body",
+            body=None,
+        )
+
+    assert len(calls) == 2