stackshift 1.0.1__tar.gz → 1.2.0__tar.gz

{stackshift-1.0.1 → stackshift-1.2.0}/PKG-INFO

@@ -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.0.1 → stackshift-1.2.0}/README.md

@@ -8,6 +8,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
@@ -205,3 +226,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.0.1 → stackshift-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackshift"
-version = "1.0.1"
+version = "1.2.0"
 description = "Official Python SDK for StackShift."
 readme = "README.md"
 requires-python = ">=3.9"

{stackshift-1.0.1 → stackshift-1.2.0}/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-1.2.0/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-1.0.1 → stackshift-1.2.0}/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-1.2.0/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-1.2.0/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-1.2.0/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-1.2.0/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-1.0.1 → stackshift-1.2.0}/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)