stackshift 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

stackshift/__init__.py

@@ -1,4 +1,5 @@
 from .client import StackShift
+from .ai_credits import AICreditsClient
 from .assets import ASSET_TRANSFORM_PRESETS, AssetsClient, asset_transform_options, asset_transform_spec, get_asset_transform_preset
 from .mail import (
     MailClient,
@@ -13,9 +14,11 @@ from .mail_streams import MailStreamsClient
 from .mail_campaigns import MailAudiencesClient, MailCampaignsClient
 from .mail_exports import MailExportsClient
 from .projects import ProjectsClient
+from .workload_security import WorkloadSecurityClient
 
 __all__ = [
     "StackShift",
+    "AICreditsClient",
     "ASSET_TRANSFORM_PRESETS",
     "AssetsClient",
     "MailClient",
@@ -33,6 +36,7 @@ __all__ = [
     "MailCampaignsClient",
     "MailExportsClient",
     "ProjectsClient",
+    "WorkloadSecurityClient",
     "asset_transform_options",
     "asset_transform_spec",
     "get_asset_transform_preset",

stackshift/ai_credits.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+
+class AICreditsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def balance(self) -> dict[str, Any]:
+        return self._client.request("GET", "/billing/ai-credits")
+
+    def usage(self, **filters: Any) -> dict[str, Any]:
+        return self._client.request("GET", "/billing/ai-credits/usage", params=filters)
+
+    def quote(self, credits: int, currency: str) -> dict[str, Any]:
+        return self._client.request("POST", "/billing/ai-credits/top-ups/quote", json={"credits": credits, "currency": currency})
+
+    def checkout(self, quote_id: str, idempotency_key: str, provider: str) -> dict[str, Any]:
+        return self._client.request("POST", "/billing/ai-credits/top-ups/checkout", json={"quote_id": quote_id, "idempotency_key": idempotency_key, "provider": provider})
+
+    def funding(self) -> dict[str, str]:
+        return self._client.request("GET", "/billing/ai-credits/funding")
+
+    def set_funding(self, product: str, mode: str) -> dict[str, str]:
+        return self._client.request("PUT", "/billing/ai-credits/funding", json={"product": product, "mode": mode})

stackshift/assets.py

@@ -7,6 +7,9 @@ from typing import Any, BinaryIO
 from urllib.parse import quote
 
 from .assets_workflows import AssetWorkflowsMixin
+from .assets_dam import AssetDAMClient
+from .assets_video import AssetVideoClient
+from .assets_platform import AssetPlatformClient
 
 
 ASSET_TRANSFORM_PRESETS: list[dict[str, Any]] = [
@@ -52,6 +55,9 @@ def asset_transform_spec(**options: Any) -> str:
 class AssetsClient(AssetWorkflowsMixin):
     def __init__(self, client: Any) -> None:
         self._client = client
+        self.dam = AssetDAMClient(client)
+        self.video = AssetVideoClient(client)
+        self.platform = AssetPlatformClient(client)
 
     def upload(
         self,

stackshift/assets_dam.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from .assets_media import AssetMediaClient
+
+
+class AssetDAMClient(AssetMediaClient):
+    def spaces(self):
+        return self._request("GET", f"/assets/spaces")
+
+    def collaborators(self):
+        return self._request("GET", f"/assets/collaborators")
+
+    def invite(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/collaborators", body=input)
+
+    def accept_invitation(self, id: str):
+        return self._request("POST", f"/assets/invitations/{quote(id, safe='')}/accept")
+
+    def update_collaborator(self, id: str, revision: int, actions: list[str]):
+        return self._request(
+            "PUT",
+            f"/assets/collaborators/{quote(id, safe='')}",
+            body={"actions": actions},
+            revision=revision,
+        )
+
+    def revoke_collaborator(self, id: str, revision: int):
+        return self._request(
+            "DELETE", f"/assets/collaborators/{quote(id, safe='')}", revision=revision
+        )
+
+    def metadata_schemas(self):
+        return self._request("GET", f"/assets/metadata-schemas")
+
+    def metadata_editor(self, asset_id: str):
+        return self._request(
+            "GET", f"/assets/{quote(asset_id, safe='')}/metadata-editor"
+        )
+
+    def create_metadata_schema(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/metadata-schemas", body=input)
+
+    def update_metadata_schema(self, id: str, revision: int, input: dict[str, Any]):
+        return self._request(
+            "PUT",
+            f"/assets/metadata-schemas/{quote(id, safe='')}",
+            body=input,
+            revision=revision,
+        )
+
+    def publish_metadata_schema(self, id: str, revision: int):
+        return self._request(
+            "POST",
+            f"/assets/metadata-schemas/{quote(id, safe='')}/publish",
+            revision=revision,
+        )
+
+    def bucket_governance(self, id: str):
+        return self._request("GET", f"/assets/buckets/{quote(id, safe='')}/governance")
+
+    def save_bucket_governance(self, id: str, input: dict[str, Any]):
+        return self._request(
+            "PUT", f"/assets/buckets/{quote(id, safe='')}/governance", body=input
+        )
+
+    def migrate_bucket_governance(self, id: str, revision: int):
+        return self._request(
+            "POST",
+            f"/assets/buckets/{quote(id, safe='')}/governance/migrate",
+            revision=revision,
+        )
+
+    def publications(self, query: dict[str, Any] | None = None):
+        return self._request("GET", f"/assets/publications", query=query)
+
+    def publication_renditions(self, asset_id: str):
+        return self._request(
+            "GET", f"/assets/{quote(asset_id, safe='')}/publication-renditions"
+        )
+
+    def create_publication(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/publications", body=input)
+
+    def update_publication(self, id: str, revision: int, input: dict[str, Any]):
+        return self._request(
+            "PUT",
+            f"/assets/publications/{quote(id, safe='')}",
+            body=input,
+            revision=revision,
+        )
+
+    def transition_publication(self, id: str, revision: int, action: str, note: str):
+        return self._request(
+            "POST",
+            f"/assets/publications/{quote(id, safe='')}/{quote(action, safe='')}",
+            body={"note": note},
+            revision=revision,
+        )
+
+    def resolve_publication(self, id: str):
+        return self._request(
+            "GET", f"/assets/publications/{quote(id, safe='')}/resolve"
+        )
+
+    def preview_publication(self, id: str):
+        return self._request(
+            "GET", f"/assets/publications/{quote(id, safe='')}/preview"
+        )
+
+    def resolve_publication_ar(self, id: str):
+        return self._request("POST", f"/assets/publications/{quote(id, safe='')}/ar")
+
+    def create_picker_capability(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/picker-capabilities", body=input)
+
+    def revoke_picker_capability(self, id: str):
+        return self._request(
+            "DELETE", f"/assets/picker-capabilities/{quote(id, safe='')}"
+        )
+
+    def models(self, asset_id: str):
+        return self._request("GET", f"/assets/{quote(asset_id, safe='')}/models")
+
+    def estimate_render(self, asset_id: str, revision: int, input: dict[str, Any]):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/models",
+            body={**input, "operation": "estimate"},
+            revision=revision,
+        )
+
+    def render_product(
+        self,
+        asset_id: str,
+        revision: int,
+        idempotency_key: str,
+        input: dict[str, Any],
+        maximum_units: int,
+    ):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/models",
+            body={**input, "operation": "render", "maximum_units": maximum_units},
+            revision=revision,
+            idempotency_key=idempotency_key,
+        )
+
+    def process_model(self, asset_id: str, revision: int, idempotency_key: str):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/models",
+            revision=revision,
+            idempotency_key=idempotency_key,
+        )
+
+    def galleries(self, query: dict[str, Any] | None = None):
+        return self._request("GET", f"/assets/galleries", query=query)
+
+    def create_gallery(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/galleries", body=input)
+
+    def update_gallery(self, id: str, revision: int, input: dict[str, Any]):
+        return self._request(
+            "PUT",
+            f"/assets/galleries/{quote(id, safe='')}",
+            body=input,
+            revision=revision,
+        )
+
+    def transition_gallery(self, id: str, revision: int, action: str):
+        return self._request(
+            "POST",
+            f"/assets/galleries/{quote(id, safe='')}/{quote(action, safe='')}",
+            revision=revision,
+        )
+
+    def resolve_gallery(self, id: str):
+        return self._request("GET", f"/assets/galleries/{quote(id, safe='')}/resolve")
+
+    def preview_gallery(self, id: str):
+        return self._request(
+            "GET", f"/assets/galleries/{quote(id, safe='')}/resolve?preview=true"
+        )
+
+    def resolve_gallery_ar(self, id: str, publication_id: str):
+        return self._request(
+            "POST",
+            f"/assets/galleries/{quote(id, safe='')}/ar",
+            body={"publication_id": publication_id},
+        )

stackshift/assets_media.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlsplit
+
+
+class AssetMediaClient:
+    def __init__(self, client: Any, space_id: str = "") -> None:
+        self._client = client
+        self._space_id = space_id
+
+    def for_space(self, space_id: str):
+        return type(self)(self._client, space_id)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body=None,
+        revision=None,
+        idempotency_key=None,
+        query=None,
+    ):
+        headers = {}
+        if self._space_id:
+            headers["X-Asset-Space-ID"] = self._space_id
+        if revision is not None:
+            headers["If-Match"] = f'"{revision}"'
+        if idempotency_key is not None:
+            headers["Idempotency-Key"] = idempotency_key
+        return self._client.request(
+            method, path, json=body, headers=headers, params=query
+        )
+
+    def _playback(self, path: str, credential: str, body: dict[str, Any]):
+        from .client import StackShift
+
+        if not credential.strip():
+            raise ValueError("Playback credential is required")
+        base = urlsplit(self._client.base_url)
+        # A separate client prevents account authentication from replacing the session credential.
+        playback = StackShift(
+            api_key=credential,
+            base_url=f"{base.scheme}://{base.netloc}",
+            session=self._client.session,
+        )
+        return playback.request("POST", "/playback" + path, json=body)

stackshift/assets_platform.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+
+def _id(value: str) -> str:
+    return quote(value, safe="")
+
+
+class _ScopedTransport:
+    def __init__(self, client: Any, space_id: str) -> None:
+        self._client = client
+        self._space_id = space_id
+
+    def request(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+        headers = dict(kwargs.pop("headers", None) or {})
+        if self._space_id:
+            headers["X-Asset-Space-ID"] = self._space_id
+        return self._client.request(method, path, headers=headers, **kwargs)
+
+
+class AssetConnectionsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def list(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/connections")
+
+    def get(self, connection_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/connections/{_id(connection_id)}")
+
+    def create(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("POST", "/assets/connections", json=input)
+
+    def update(self, connection_id: str, input: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("PATCH", f"/assets/connections/{_id(connection_id)}", json=input)
+
+    def verify(self, connection_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/connections/{_id(connection_id)}/verify")
+
+    def delete(self, connection_id: str) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/connections/{_id(connection_id)}")
+
+
+class AssetStorageClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def configure(self, bucket_id: str, revision: int, input: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("PUT", f"/assets/buckets/{_id(bucket_id)}/storage",
+                                    json=input, headers={"If-Match": f'"{revision}"'})
+
+    def list_s2_buckets(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/s2-buckets")
+
+    def create_s2_bucket(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("POST", "/assets/s2-buckets", json=input)
+
+    def relocate(self, bucket_id: str, input: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/buckets/{_id(bucket_id)}/relocations",
+                                    json=input or {})
+
+
+class AssetMigrationsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def start(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("POST", "/assets/migrations", json=input)
+
+    def list(self, limit: int | None = None) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/migrations",
+                                    params={"limit": limit} if limit is not None else None)
+
+    def get(self, migration_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/migrations/{_id(migration_id)}")
+
+    def cancel(self, migration_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/migrations/{_id(migration_id)}/cancel")
+
+    def retry_item(self, migration_id: str, item_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/migrations/{_id(migration_id)}/items/{_id(item_id)}/retry")
+
+    def report(self, migration_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/migrations/{_id(migration_id)}/report",
+                                    params={"format": "json"})
+
+
+class AssetPlatformClient:
+    def __init__(self, client: Any, space_id: str = "") -> None:
+        self._client = client
+        transport = _ScopedTransport(client, space_id)
+        self.connections = AssetConnectionsClient(transport)
+        self.storage = AssetStorageClient(transport)
+        self.migrations = AssetMigrationsClient(transport)
+
+    def for_space(self, space_id: str) -> AssetPlatformClient:
+        return type(self)(self._client, space_id)

stackshift/assets_video.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from .assets_media import AssetMediaClient
+
+
+class AssetVideoClient(AssetMediaClient):
+    def workspace(self, asset_id: str):
+        return self._request("GET", f"/assets/{quote(asset_id, safe='')}/video")
+
+    def process(self, asset_id: str, version_id: str):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video",
+        )
+
+    def create_session(self, asset_id: str):
+        return self._request(
+            "POST", f"/assets/{quote(asset_id, safe='')}/playback-sessions"
+        )
+
+    def revoke_session(self, asset_id: str, session_id: str):
+        return self._request(
+            "DELETE",
+            f"/assets/{quote(asset_id, safe='')}/playback-sessions/{quote(session_id, safe='')}",
+        )
+
+    def captions(self, asset_id: str, version_id: str):
+        return self._request(
+            "GET",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video/captions",
+        )
+
+    def add_caption(self, asset_id: str, version_id: str, input: dict[str, Any]):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video/captions",
+            body=input,
+        )
+
+    def remove_caption(self, asset_id: str, version_id: str, caption_id: str):
+        return self._request(
+            "DELETE",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video/captions/{quote(caption_id, safe='')}",
+        )
+
+    def review(self, asset_id: str, version_id: str, decision: str, reason: str):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video/review",
+            body={"decision": decision, "reason": reason},
+        )
+
+    def analytics(self, asset_id: str):
+        return self._request(
+            "GET", f"/assets/{quote(asset_id, safe='')}/video/analytics"
+        )
+
+    def renew_session(self, credential: str):
+        return self._playback("/sessions/renew", credential, {})
+
+    def events(self, credential: str, events: list[dict[str, Any]]):
+        return self._playback("/events", credential, {"events": events})

stackshift/client.py

@@ -26,13 +26,17 @@ class StackShift:
         self.cdn_base_url = cdn_base_url.rstrip("/")
         self.session = session or requests.Session()
 
+        from .ai_credits import AICreditsClient
         from .assets import AssetsClient
         from .mail import MailClient
         from .projects import ProjectsClient
+        from .workload_security import WorkloadSecurityClient
 
+        self.ai_credits = AICreditsClient(self)
         self.projects = ProjectsClient(self)
         self.assets = AssetsClient(self)
         self.mail = MailClient(self)
+        self.workload_security = WorkloadSecurityClient(self)
 
     def request(self, method: str, path: str, **kwargs: Any) -> Any:
         return self._request(self.base_url, method, path, **kwargs)

stackshift/mail.py

@@ -7,8 +7,13 @@ from .mail_advanced import MailAnalyticsClient, MailBatchClient, MailInboundClie
 from .mail_events_webhooks import MailEventsClient, MailWebhooksClient
 from .mail_reputation import MailLimitsClient, MailReputationClient
 from .mail_streams import MailStreamsClient
+from .mail_brands import MailBrandsClient
+from .mail_billing import MailBillingClient
+from .mail_marketing import MailAutomationsClient, MailFormsClient, MailSegmentsClient
+from .mail_migration import MailMigrationClient
 from .mail_campaigns import MailAudiencesClient, MailCampaignsClient
 from .mail_exports import MailExportsClient
+from .mail_tracking import MailTrackingClient
 
 
 class MailClient:
@@ -23,8 +28,15 @@ class MailClient:
         self.events = MailEventsClient(client)
         self.webhooks = MailWebhooksClient(client)
         self.streams = MailStreamsClient(client)
+        self.brands = MailBrandsClient(client)
+        self.billing = MailBillingClient(client)
+        self.automations = MailAutomationsClient(client)
+        self.forms = MailFormsClient(client)
+        self.segments = MailSegmentsClient(client)
+        self.migration = MailMigrationClient(client)
         self.audiences = MailAudiencesClient(client)
         self.campaigns = MailCampaignsClient(client)
+        self.tracking = MailTrackingClient(client)
         self.exports = MailExportsClient(client)
         self.limits = MailLimitsClient(client)
         self.reputation = MailReputationClient(client)
@@ -49,6 +61,8 @@ class MailClient:
         headers: dict[str, str] | None = None,
         tags: dict[str, str] | None = None,
         stream: str | None = None,
+        tracking: dict[str, bool] | None = None,
+        simulation: dict[str, str] | None = None,
     ) -> dict[str, Any]:
         payload = {
             "from": from_,
@@ -64,6 +78,8 @@ class MailClient:
             "headers": headers,
             "tags": tags,
             "stream": stream,
+            "tracking": tracking,
+            "simulation": simulation,
         }
         clean = {key: value for key, value in payload.items() if value is not None}
         return self._client.mail_request("POST", "/mail/send", json=clean)
@@ -84,6 +100,8 @@ class MailClient:
         headers: dict[str, str] | None = None,
         tags: dict[str, str] | None = None,
         stream: str | None = None,
+        tracking: dict[str, bool] | None = None,
+        simulation: dict[str, str] | None = None,
     ) -> dict[str, Any]:
         payload = {
             "template": template,
@@ -99,6 +117,8 @@ class MailClient:
             "headers": headers,
             "tags": tags,
             "stream": stream,
+            "tracking": tracking,
+            "simulation": simulation,
         }
         clean = {key: value for key, value in payload.items() if value is not None}
         return self._client.mail_request("POST", "/mail/send-template", json=clean)
@@ -201,8 +221,9 @@ class MailTemplatesClient:
         data: dict[str, Any],
         from_: str | dict[str, str] | None = None,
         version_id: str | None = None,
+        simulation: dict[str, str] | None = None,
     ) -> dict[str, Any]:
-        payload = {"to": to, "from": from_, "data": data, "versionId": version_id}
+        payload = {"simulation": simulation, "to": to, "from": from_, "data": data, "versionId": version_id}
         clean = {key: value for key, value in payload.items() if value is not None}
         return self._client.mail_request("POST", f"/mail/templates/{quote(template_id)}/test-send", json=clean)
 
@@ -348,6 +369,7 @@ class MailOTPClient:
         idempotency_key: str | None = None,
         subject: str | None = None,
         brand_name: str | None = None,
+        simulation: dict[str, str] | None = None,
     ) -> dict[str, Any]:
         payload = {
             "to": to,
@@ -359,6 +381,7 @@ class MailOTPClient:
             "idempotencyKey": idempotency_key,
             "subject": subject,
             "brandName": brand_name,
+            "simulation": simulation,
         }
         clean = {key: value for key, value in payload.items() if value is not None}
         return self._client.mail_request("POST", "/mail/otp/send", json=clean)

stackshift/mail_advanced.py

@@ -39,6 +39,8 @@ class MailBatchClient:
         headers: dict[str, str] | None = None,
         tags: dict[str, str] | None = None,
         stream: str | None = None,
+        tracking: dict[str, bool] | None = None,
+        simulation: dict[str, str] | None = None,
     ) -> dict[str, Any]:
         payload = {
             "template": template,
@@ -48,6 +50,8 @@ class MailBatchClient:
             "headers": headers,
             "tags": tags,
             "stream": stream,
+            "tracking": tracking,
+            "simulation": simulation,
         }
         clean = {key: value for key, value in payload.items() if value is not None}
         return self._client.mail_request("POST", "/mail/batch-template", json=clean)

stackshift/mail_billing.py

@@ -0,0 +1,9 @@
+from typing import Any
+
+
+class MailBillingClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def summary(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/billing")

stackshift/mail_brands.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+
+class MailBrandsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(self, *, name: str, **fields: Any) -> dict[str, Any]:
+        return self._client.mail_request("POST", "/mail/brands", json={"name": name, **_brand_fields(fields)})
+
+    def list(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/brands")
+
+    def get(self, brand_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/brands/{quote(brand_id, safe='')}")
+
+    def update(self, brand_id: str, *, revision: int, name: str, **fields: Any) -> dict[str, Any]:
+        return self._client.mail_request(
+            "PUT", f"/mail/brands/{quote(brand_id, safe='')}",
+            json={"revision": revision, "name": name, **_brand_fields(fields)},
+        )
+
+    def archive(self, brand_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/brands/{quote(brand_id, safe='')}/archive")
+
+
+def _brand_fields(fields: dict[str, Any]) -> dict[str, Any]:
+    names = {"logo_url": "logoUrl", "sending_domain_id": "sendingDomainId", "default_from": "defaultFrom", "reply_to": "replyTo", "postal_address": "postalAddress", "website": "website", "support_email": "supportEmail", "editable_fields": "editableFields"}
+    unknown = fields.keys() - names.keys() - set(names.values())
+    if unknown:
+        raise ValueError("Unknown brand fields: " + ", ".join(sorted(unknown)))
+    return {names.get(key, key): value for key, value in fields.items()}

stackshift/mail_campaigns.py

@@ -8,26 +8,48 @@ class MailAudiencesClient:
     def __init__(self, client: Any) -> None:
         self._client = client
 
-    def create(self, *, name: str, description: str | None = None) -> dict[str, Any]:
-        payload = {"name": name, "description": description}
+    def create(self, *, brand_id: str, name: str, description: str | None = None) -> dict[str, Any]:
+        payload = {"brandId": brand_id, "name": name, "description": description}
         return self._client.mail_request("POST", "/mail/audiences", json={key: value for key, value in payload.items() if value is not None})
 
     def list(self) -> dict[str, Any]:
         return self._client.mail_request("GET", "/mail/audiences")
 
     def get(self, audience_id: str) -> dict[str, Any]:
-        return self._client.mail_request("GET", f"/mail/audiences/{quote(audience_id)}")
+        return self._client.mail_request("GET", f"/mail/audiences/{quote(audience_id, safe='')}")
 
     def members(self, audience_id: str) -> dict[str, Any]:
-        return self._client.mail_request("GET", f"/mail/audiences/{quote(audience_id)}/members")
+        return self._client.mail_request("GET", f"/mail/audiences/{quote(audience_id, safe='')}/members")
 
     def import_members(self, audience_id: str, members: list[dict[str, Any]]) -> dict[str, Any]:
         return self._client.mail_request(
             "POST",
-            f"/mail/audiences/{quote(audience_id)}/imports",
+            f"/mail/audiences/{quote(audience_id, safe='')}/imports",
             json={"members": members},
         )
 
+    def preview_import(
+        self, audience_id: str, members: list[dict[str, Any]], *, mode: str = "recorded_consent"
+    ) -> dict[str, Any]:
+        return self._client.mail_request(
+            "POST", f"/mail/audiences/{quote(audience_id, safe='')}/imports/preview",
+            json={"members": members, "mode": mode},
+        )
+
+    def import_detailed(
+        self, audience_id: str, members: list[dict[str, Any]], *, mode: str = "recorded_consent"
+    ) -> dict[str, Any]:
+        return self._client.mail_request(
+            "POST", f"/mail/audiences/{quote(audience_id, safe='')}/imports",
+            json={"members": members, "mode": mode},
+        )
+
+    def set_editable_fields(self, audience_id: str, fields: list[str]) -> dict[str, Any]:
+        return self._client.mail_request(
+            "PUT", f"/mail/audiences/{quote(audience_id, safe='')}/preferences",
+            json={"editableFields": fields},
+        )
+
 
 class MailCampaignsClient:
     def __init__(self, client: Any) -> None:
@@ -38,9 +60,16 @@ class MailCampaignsClient:
         *,
         name: str,
         audience_id: str,
-        template: str,
-        from_: str,
+        template: str = "",
+        from_: str = "",
         version_id: str | None = None,
+        content: dict[str, Any] | None = None,
+        variant_b_content: dict[str, Any] | None = None,
+        variant_b_percent: int = 0,
+        segment_id: str | None = None,
+        reply_to: str | None = None,
+        tracking: dict[str, bool] | None = None,
+        simulation: dict[str, str] | None = None,
     ) -> dict[str, Any]:
         payload = {
             "name": name,
@@ -48,6 +77,9 @@ class MailCampaignsClient:
             "template": template,
             "from": from_,
             "versionId": version_id,
+            "content": content, "variantBContent": variant_b_content,
+            "variantBPercent": variant_b_percent, "segmentId": segment_id,
+            "replyTo": reply_to, "tracking": tracking, "simulation": simulation,
         }
         return self._client.mail_request("POST", "/mail/campaigns", json={key: value for key, value in payload.items() if value is not None})
 
@@ -57,5 +89,20 @@ class MailCampaignsClient:
     def get(self, campaign_id: str) -> dict[str, Any]:
         return self._client.mail_request("GET", f"/mail/campaigns/{quote(campaign_id)}")
 
-    def send(self, campaign_id: str) -> dict[str, Any]:
-        return self._client.mail_request("POST", f"/mail/campaigns/{quote(campaign_id)}/send")
+    def send(self, campaign_id: str, *, revision: int | None = None, approved_max_kobo: int | None = None) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/campaigns/{quote(campaign_id, safe='')}/send", json={key: value for key, value in {"revision": revision, "approvedMaxKobo": approved_max_kobo}.items() if value is not None})
+
+    def update(self, campaign_id: str, *, revision: int, **draft: Any) -> dict[str, Any]:
+        return self._client.mail_request("PUT", f"/mail/campaigns/{quote(campaign_id, safe='')}", json={**draft, "revision": revision})
+
+    def preview(self, campaign_id: str, data: dict[str, Any] | None = None, variant: str = "a") -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/campaigns/{quote(campaign_id, safe='')}/preview", json={"data": data or {}, "variant": variant})
+
+    def test(self, campaign_id: str, to: str, data: dict[str, Any] | None = None, variant: str = "a", simulation: dict[str, str] | None = None) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/campaigns/{quote(campaign_id, safe='')}/test", json={"to": to, "data": data or {}, "variant": variant, **({"simulation": simulation} if simulation else {})})
+
+    def schedule(self, campaign_id: str, send_at: str, *, revision: int | None = None, approved_max_kobo: int | None = None) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/campaigns/{quote(campaign_id, safe='')}/schedule", json={"sendAt": send_at, **({"revision": revision} if revision is not None else {}), **({"approvedMaxKobo": approved_max_kobo} if approved_max_kobo is not None else {})})
+
+    def estimate(self, campaign_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/campaigns/{quote(campaign_id, safe='')}/estimate")

stackshift/mail_marketing.py

@@ -0,0 +1,35 @@
+from typing import Any
+
+class MailAutomationsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._client.mail_request("POST", "/mail/automations", json=input)
+
+    def list(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/automations")
+
+
+class MailFormsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._client.mail_request("POST", "/mail/forms", json=input)
+
+    def list(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/forms")
+
+
+class MailSegmentsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(self, input: dict[str, Any]) -> dict[str, Any]:
+        return self._client.mail_request("POST", "/mail/segments", json=input)
+
+    def list(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/segments")
+
+

stackshift/mail_migration.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class MailMigrationClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def audit(self, domain: str, selectors: list[str] | None = None) -> dict[str, Any]:
+        return self._client.request("GET", "/mail/audit", params={"domain": domain, "selectors": ",".join(selectors or [])})
+
+    def plan(self, domain: str, provider: str, selectors: list[str] | None = None) -> dict[str, Any]:
+        return self._client.request("GET", "/mail/migration-plan", params={"domain": domain, "provider": provider, "selectors": ",".join(selectors or [])})
+
+    def checklist(self, domain: str, provider: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/migration/checklist", params={"domain": domain, "provider": provider})
+
+    def save_checklist(self, domain: str, provider: str, completed: list[str], *, revision: int) -> dict[str, Any]:
+        return self._client.mail_request("PUT", "/mail/migration/checklist", json={"domain": domain, "provider": provider, "completed": completed, "revision": revision})

stackshift/mail_tracking.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+
+class MailTrackingClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def settings(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/tracking/settings")
+
+    def update_settings(self, *, opens: bool, clicks: bool) -> dict[str, Any]:
+        return self._client.mail_request("PUT", "/mail/tracking/settings", json={"opens": opens, "clicks": clicks})
+
+    def message(self, message_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/messages/{quote(message_id, safe='')}/engagement")
+
+    def campaign(self, campaign_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/campaigns/{quote(campaign_id, safe='')}/engagement")
+
+    def domains(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/tracking/domains")
+
+    def create_domain(self, domain_id: str, hostname: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", "/mail/tracking/domains", json={"domainId": domain_id, "hostname": hostname})
+
+    def verify_domain(self, domain_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/tracking/domains/{quote(domain_id, safe='')}/verify")
+
+    def update_domain(self, domain_id: str, *, enabled: bool, revoke: bool = False) -> None:
+        self._client.mail_request("PUT", f"/mail/tracking/domains/{quote(domain_id, safe='')}", json={"enabled": enabled, "revoke": revoke})

stackshift/workload_security.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+
+class WorkloadSecurityClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    @staticmethod
+    def _root(project_id: str) -> str:
+        return f"/projects/{quote(project_id, safe='')}/security"
+
+    def admissions(self, project_id: str, *, limit: int | None = None) -> dict[str, Any]:
+        return self._client.request("GET", f"{self._root(project_id)}/admissions", params=_params(limit=limit))
+
+    def policy(self, project_id: str, *, environment: str | None = None) -> dict[str, Any]:
+        return self._client.request("GET", f"{self._root(project_id)}/policy", params=_params(environment=environment))
+
+    def dependencies(self, project_id: str, *, environment: str | None = None) -> dict[str, Any]:
+        return self._client.request("GET", f"{self._root(project_id)}/dependencies", params=_params(environment=environment))
+
+    def declare_dependency(self, project_id: str, dependency: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("POST", f"{self._root(project_id)}/dependencies", json=dependency)
+
+    def refresh_dependencies(self, project_id: str, environment: str) -> dict[str, Any]:
+        return self._client.request(
+            "POST",
+            f"{self._root(project_id)}/dependencies/refresh",
+            json={"environment": environment},
+        )
+
+    def grants(self, project_id: str, *, environment: str | None = None) -> dict[str, Any]:
+        return self._client.request("GET", f"{self._root(project_id)}/grants", params=_params(environment=environment))
+
+    def request_grant(self, project_id: str, grant: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("POST", f"{self._root(project_id)}/grants", json=grant)
+
+    def private_routes(self, project_id: str, *, environment: str | None = None) -> dict[str, Any]:
+        return self._client.request("GET", f"{self._root(project_id)}/private-routes", params=_params(environment=environment))
+
+    def request_private_route(self, project_id: str, route: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("POST", f"{self._root(project_id)}/private-routes", json=route)
+
+    def incidents(
+        self,
+        project_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+    ) -> dict[str, Any]:
+        return self._client.request(
+            "GET",
+            f"{self._root(project_id)}/incidents",
+            params=_params(status=status, limit=limit),
+        )
+
+    def incident(self, project_id: str, incident_id: str) -> dict[str, Any]:
+        return self._client.request(
+            "GET",
+            f"{self._root(project_id)}/incidents/{quote(incident_id, safe='')}",
+        )
+
+
+def _params(**values: Any) -> dict[str, Any]:
+    return {key: value for key, value in values.items() if value not in (None, "")}

{stackshift-1.0.1.dist-info → stackshift-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackshift
-Version: 1.0.1
+Version: 1.2.0
 Summary: Official Python SDK for StackShift.
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -16,6 +16,27 @@ Official Python SDK for StackShift.
 pip install stackshift
 ```
 
+## AI credits
+
+AI credits are account-scoped. Use the shared client to inspect usage, start a top-up, or select managed billing versus your own provider key:
+
+```python
+from stackshift import StackShift
+
+stackshift = StackShift()
+balance = stackshift.ai_credits.balance()
+usage = stackshift.ai_credits.usage(product="assets", limit=25)
+quote = stackshift.ai_credits.quote(1_000, "USD")
+checkout = stackshift.ai_credits.checkout(
+    quote["id"],
+    "unique-checkout-id",
+    "paystack",
+)
+stackshift.ai_credits.set_funding("assets", "managed")
+```
+
+Keep account API keys and checkout creation on your server.
+
 ## Send email
 
 ```python
@@ -213,3 +234,51 @@ upload = stackshift.assets.signed_upload_url(
 Then upload the browser `File` to `upload["url"]` from your frontend. Do not expose your StackShift API key to browser code.
 
 The SDK only talks to the StackShift REST API. Storage placement, replication, disks, and repair are StackShift internals.
+
+### Campaign drafts and engagement
+
+`mail.campaigns.create(content={...})` accepts a private campaign content snapshot; template/version inputs still work. Save the complete draft with `update(id, revision=revision, **draft)` (draft keys use API camelCase). `preview`, `test`, `send(id, revision=revision)`, and `schedule(id, send_at, revision=revision)` protect the reviewed content. Stale revisions return 409.
+
+Send methods accept `tracking={"opens": False, "clicks": True}`. Omitted fields inherit workspace defaults. `mail.tracking` exposes `settings`, `update_settings`, `message`, `campaign`, and branded-domain methods. Deployment capability flags control availability. Opens are approximate; detailed activity expires after 90 days. OTPs and tests never track.
+
+### Isolated testing, brands, migration, and spending
+
+Use a `sspat_test_` credential and `simulation={"scenario": "delayed"}` for a 60-second simulated delay. Delivered, bounced, and complained outcomes are also supported. Test resources are isolated; no real email is delivered.
+
+```python
+brand = client.mail.brands.create(name="Product", editable_fields=["company"])
+audience = client.mail.audiences.create(brand_id=brand["id"], name="Product news")
+```
+
+Audience creation requires an explicit `brand_id`. Shared profile fields belong to the brand; consent stays per audience. `mail.automations`, `mail.forms`, and `mail.segments` expose create/list methods; their input dictionaries use API camelCase keys.
+
+`mail.migration` supports public DNS audits/plans and authenticated checklists. `mail.billing.summary()` and `mail.campaigns.estimate(id)` expose allowance and credit. Pass `approved_max_kobo=0` (or another approved maximum) alongside `revision` when sending/scheduling campaigns. Billing remains inactive until a rate card is explicitly published and activated; funding and spending opt-in are separate owner-only dashboard actions.
+
+## Native video, governed DAM and product rendering
+
+Use the space-scoped DAM and video clients for collaborators, metadata schemas, bucket governance, reviewed publications, picker capabilities, model preparation, product rendering, galleries, version-pinned encoding, captions and playback sessions.
+
+```python
+dam = sdk.assets.dam.for_space(space_id)
+video = sdk.assets.video.for_space(space_id)
+schema = dam.create_metadata_schema({"name": "Products", "fields": [{
+    "key": "product_name", "label": "Product name", "type": "text", "required": True,
+}]})
+published = dam.publish_metadata_schema(schema["id"], schema["revision"])
+workspace = video.workspace(asset_id)
+```
+
+Mutations carry the supplied revision in `If-Match`. Model preparation and rendering carry an idempotency key; render submission also carries the accepted maximum units. Playback renewal and events authenticate with the session credential, not the account key. Keep these clients on your backend and return grants with `Cache-Control: private, no-store`.
+
+See the [Assets SDK guide](https://docs.stackshift.cloud/assets/sdk-media-workflows) and its linked feature guides for complete language examples, inputs, permissions, review transitions and browser callbacks.
+
+## Assets storage and Cloudinary migration
+
+`sdk.assets.platform.for_space(space_id)` exposes `connections`, `storage`, and `migrations`. Use a verified Cloudinary connection, run a dry migration first, inspect its report, then start the transfer with the same folder prefix and conflict policy.
+
+```python
+platform = sdk.assets.platform.for_space(space_id)
+preview = platform.migrations.start({"source_connection_id": connection_id,
+    "destination_bucket_id": bucket_id, "source_prefix": "campaigns/2026", "dry_run": True})
+report = platform.migrations.report(preview["id"])
+```

stackshift-1.2.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+stackshift/__init__.py,sha256=6w_s5ELWH4aYV4NXysotLKIX1XdHif0ny_3WGaiGZSY,1425
+stackshift/ai_credits.py,sha256=2u5zGSBo_spHqgYJhtmChaEiBq9jUVaTjR1uprxMpNQ,1142
+stackshift/assets.py,sha256=qjV59NFxQEF6_56GdMZVrN_QadExFbDWbcbiBFYXCt0,23292
+stackshift/assets_dam.py,sha256=dz0QgSZuQcwSSYoWFqy1pCx3xgMGYZLc9tCcQE0_kYo,6659
+stackshift/assets_media.py,sha256=S_7TWu6hm5I8WUPMfQsGE9U15mDiYRG4ygXJzWqwbDE,1523
+stackshift/assets_platform.py,sha256=w2Eke0YFXinmtHt1oaZlaiP_J32VymfhVWWLOYrX93M,4125
+stackshift/assets_video.py,sha256=KBIOTsVspHcMltkELsbTmfu-VB6_36dpYQ7HKTqAa2E,2374
+stackshift/assets_workflows.py,sha256=6L8_1d9huhfSrKovwP26tfGKc38o0sbSM-75dt__HRE,6950
+stackshift/client.py,sha256=4osuRDTVvBoZGKKhYBmZkx-oCAezg9zWxB2olXlnqsM,3220
+stackshift/mail.py,sha256=Ny8aEE846vzanT0B8uqyBB0BGm1p4OmERC0zX_6mGPg,15989
+stackshift/mail_advanced.py,sha256=sLte3we0Oy3pSuwjl5c4lfELH6gzaSUKug_WZDUB2DE,4363
+stackshift/mail_billing.py,sha256=n1SMNTHW5lVs7phJhZBiKw6ok-T3kbW0A3-4uF1w6Yg,232
+stackshift/mail_brands.py,sha256=aaOzETtfix0pFpaWBOHYPVrfUZezWqt53ZXJQk1F7mY,1627
+stackshift/mail_campaigns.py,sha256=WAMMQxKt7BvsPzJuJE-uCiLFoyJ1RKh_pD3azWINGXA,5424
+stackshift/mail_events_webhooks.py,sha256=iVYz_5DvGaE-Acw5uh_JN7P5LWvgfN-2bLnb_z1CMRU,5712
+stackshift/mail_exports.py,sha256=sbwBbypS1APv2DnunYmyViEjUHP1PMSrM0tVcbxcits,1054
+stackshift/mail_marketing.py,sha256=7uMZQYjU0siMyqFas_i5YWJTrwT9eYMrWElRThxZMr4,1077
+stackshift/mail_migration.py,sha256=j-VvEbJP92ndQ5HMhdu7obJ4S_4gka7oqNRirIvYkyE,1121
+stackshift/mail_reputation.py,sha256=mPvPkZeqcQc5808PhBK7gYsgf4Fk_U19nRxSsJ60MGU,1112
+stackshift/mail_streams.py,sha256=F7iBzHtWhCFw1cTjwPixNJfCvxdjvsDprZQG2A9-NIs,504
+stackshift/mail_tracking.py,sha256=SRcWTI9Otm5fBIY7nJJ-5qZA13aybUuMdh_PqakBpUg,1575
+stackshift/projects.py,sha256=oYWaE7xNRR6OXuPEwJH-oFFeOmDA9ozq6jJY09ANIHA,498
+stackshift/workload_security.py,sha256=5JtJH9fX1kqSY3ipXUa79JslUULWsN5_gyn9tTGfzlA,2941
+stackshift-1.2.0.dist-info/METADATA,sha256=DZCSjepFeKmKNajeXmUZbNsMaxoG8en0kcxOit3JCPk,10250
+stackshift-1.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+stackshift-1.2.0.dist-info/top_level.txt,sha256=qe3uWsu_O9mNtq7bIck9Y8rjTIMrH0kzgAlGFDoRGqs,11
+stackshift-1.2.0.dist-info/RECORD,,

stackshift-1.0.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-stackshift/__init__.py,sha256=QJxD-b_E7P0_6s04v1GhbyyaXLweNohIZPnwmS-jUAc,1278
-stackshift/assets.py,sha256=h7PjWQzBVtbpBn0_treRVfPXQw0rJCXBCXVBkC8jIhs,23021
-stackshift/assets_workflows.py,sha256=6L8_1d9huhfSrKovwP26tfGKc38o0sbSM-75dt__HRE,6950
-stackshift/client.py,sha256=myLN4B_SsolilJWpdlTZv8xwYnj1q-xOmjcSaF_P0mM,3000
-stackshift/mail.py,sha256=akjk8ATJLl7Wv8b2re9LPL5n2Vjvjnz8HK6yNhP6Vj0,14863
-stackshift/mail_advanced.py,sha256=e7Z0SCvonNaS36BnEfhioUh9fnZDU2vcIKmqc1Mqmvo,4192
-stackshift/mail_campaigns.py,sha256=-ZQV88gY1PsuKNA4KYcKVqS1To39EOukKu1Is9qRCPU,2198
-stackshift/mail_events_webhooks.py,sha256=iVYz_5DvGaE-Acw5uh_JN7P5LWvgfN-2bLnb_z1CMRU,5712
-stackshift/mail_exports.py,sha256=sbwBbypS1APv2DnunYmyViEjUHP1PMSrM0tVcbxcits,1054
-stackshift/mail_reputation.py,sha256=mPvPkZeqcQc5808PhBK7gYsgf4Fk_U19nRxSsJ60MGU,1112
-stackshift/mail_streams.py,sha256=F7iBzHtWhCFw1cTjwPixNJfCvxdjvsDprZQG2A9-NIs,504
-stackshift/projects.py,sha256=oYWaE7xNRR6OXuPEwJH-oFFeOmDA9ozq6jJY09ANIHA,498
-stackshift-1.0.1.dist-info/METADATA,sha256=B2WaO3NpgVHvZcIcT05RA_MRd5rouC9wlB93AwrQXME,5893
-stackshift-1.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-stackshift-1.0.1.dist-info/top_level.txt,sha256=qe3uWsu_O9mNtq7bIck9Y8rjTIMrH0kzgAlGFDoRGqs,11
-stackshift-1.0.1.dist-info/RECORD,,