stackshift 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

stackshift/__init__.py

@@ -1,5 +1,33 @@
 from .client import StackShift
-from .assets import AssetsClient
+from .assets import ASSET_TRANSFORM_PRESETS, AssetsClient, asset_transform_options, asset_transform_spec, get_asset_transform_preset
+from .mail import (
+    MailClient,
+    MailDomainsClient,
+    MailOTPChallengesClient,
+    MailOTPClient,
+    MailTemplatesClient,
+)
+from .mail_reputation import MailLimitsClient, MailReputationClient, MailReputationEventsClient
+from .mail_phase7 import MailEventsClient, MailWebhooksClient, verify_webhook_signature
 from .projects import ProjectsClient
 
-__all__ = ["StackShift", "AssetsClient", "ProjectsClient"]
+__all__ = [
+    "StackShift",
+    "ASSET_TRANSFORM_PRESETS",
+    "AssetsClient",
+    "MailClient",
+    "MailDomainsClient",
+    "MailEventsClient",
+    "MailLimitsClient",
+    "MailOTPClient",
+    "MailOTPChallengesClient",
+    "MailReputationClient",
+    "MailReputationEventsClient",
+    "MailTemplatesClient",
+    "MailWebhooksClient",
+    "ProjectsClient",
+    "asset_transform_options",
+    "asset_transform_spec",
+    "get_asset_transform_preset",
+    "verify_webhook_signature",
+]

stackshift/assets.py

@@ -1,8 +1,50 @@
 from __future__ import annotations
 
 import json
+import hashlib
 from pathlib import Path
 from typing import Any, BinaryIO
+from urllib.parse import quote
+
+
+ASSET_TRANSFORM_PRESETS: list[dict[str, Any]] = [
+    {"id": "web-thumbnail", "name": "web-thumbnail", "category": "responsive-web", "description": "Compact grid thumbnail for libraries and dashboards.", "width": 320, "height": 180, "crop": "fill", "format": "webp", "quality": 78},
+    {"id": "web-card", "name": "web-card", "category": "responsive-web", "description": "Balanced card image for product and content listings.", "width": 640, "height": 360, "crop": "fill", "format": "webp", "quality": 82},
+    {"id": "feature-image", "name": "feature-image", "category": "responsive-web", "description": "Wide content feature image with enough detail for retina screens.", "width": 1200, "height": 675, "crop": "fill", "format": "webp", "quality": 84},
+    {"id": "hero", "name": "hero", "category": "responsive-web", "description": "Large hero image for landing pages and page headers.", "width": 1600, "height": 900, "crop": "fill", "format": "webp", "quality": 84},
+    {"id": "full-width-banner", "name": "full-width-banner", "category": "responsive-web", "description": "Extra-wide banner for app shells and marketing sections.", "width": 1920, "height": 720, "crop": "fill", "format": "webp", "quality": 82},
+    {"id": "open-graph", "name": "open-graph", "category": "social", "description": "Share preview image for Open Graph cards.", "width": 1200, "height": 630, "crop": "fill", "format": "jpeg", "quality": 85},
+    {"id": "square-post", "name": "square-post", "category": "social", "description": "Square image for social feeds.", "width": 1080, "height": 1080, "crop": "fill", "format": "webp", "quality": 84},
+    {"id": "story", "name": "story", "category": "social", "description": "Vertical story format for mobile social placements.", "width": 1080, "height": 1920, "crop": "fill", "format": "webp", "quality": 82},
+    {"id": "x-twitter-card", "name": "x-twitter-card", "category": "social", "description": "Landscape card optimized for X and Twitter previews.", "width": 1200, "height": 675, "crop": "fill", "format": "jpeg", "quality": 84},
+    {"id": "linkedin-share", "name": "linkedin-share", "category": "social", "description": "LinkedIn share preview dimensions.", "width": 1200, "height": 627, "crop": "fill", "format": "jpeg", "quality": 84},
+    {"id": "product-square", "name": "product-square", "category": "product", "description": "Square product image with clean containment.", "width": 1024, "height": 1024, "crop": "fit", "format": "webp", "quality": 86},
+    {"id": "product-card", "name": "product-card", "category": "product", "description": "Product listing image for commerce grids.", "width": 640, "height": 640, "crop": "fit", "format": "webp", "quality": 84},
+    {"id": "product-zoom", "name": "product-zoom", "category": "product", "description": "High-detail product image for zoom interactions.", "width": 2000, "height": 2000, "crop": "fit", "format": "jpeg", "quality": 90},
+    {"id": "gallery-thumb", "name": "gallery-thumb", "category": "product", "description": "Compact gallery thumbnail for product detail pages.", "width": 400, "height": 400, "crop": "fill", "format": "webp", "quality": 82},
+    {"id": "avatar-small", "name": "avatar-small", "category": "avatar-profile", "description": "Small circular avatar source for dense UI.", "width": 128, "height": 128, "crop": "fill", "format": "webp", "quality": 82},
+    {"id": "avatar-retina", "name": "avatar-retina", "category": "avatar-profile", "description": "Retina avatar source for account and profile UI.", "width": 256, "height": 256, "crop": "fill", "format": "webp", "quality": 84},
+    {"id": "profile-cover", "name": "profile-cover", "category": "avatar-profile", "description": "Wide profile cover image.", "width": 1500, "height": 500, "crop": "fill", "format": "webp", "quality": 82},
+    {"id": "webp-auto", "name": "webp-auto", "category": "performance", "description": "Auto-sized WebP delivery with browser-friendly compression.", "width": 1280, "crop": "fit", "format": "webp", "quality": 78},
+    {"id": "avif-compressed", "name": "avif-compressed", "category": "performance", "description": "Highly compressed AVIF for modern browsers.", "width": 1280, "crop": "fit", "format": "avif", "quality": 62},
+    {"id": "lqip", "name": "lqip", "category": "performance", "description": "Tiny low-quality placeholder for progressive image loading.", "width": 48, "crop": "fit", "format": "jpeg", "quality": 35},
+    {"id": "blur-placeholder", "name": "blur-placeholder", "category": "performance", "description": "Small placeholder candidate for blurred loading states.", "width": 32, "height": 32, "crop": "fill", "format": "jpeg", "quality": 30},
+    {"id": "email-safe-600", "name": "email-safe-600", "category": "email-docs", "description": "Email-safe content image with conservative width.", "width": 600, "crop": "fit", "format": "jpeg", "quality": 82},
+    {"id": "markdown-image", "name": "markdown-image", "category": "email-docs", "description": "Documentation image that fits most reading columns.", "width": 800, "crop": "fit", "format": "webp", "quality": 82},
+    {"id": "docs-screenshot", "name": "docs-screenshot", "category": "email-docs", "description": "Crisp screenshot size for guides and changelogs.", "width": 1440, "height": 900, "crop": "fit", "format": "webp", "quality": 84},
+]
+
+
+def get_asset_transform_preset(name: str) -> dict[str, Any] | None:
+    return next((preset for preset in ASSET_TRANSFORM_PRESETS if preset["name"] == name), None)
+
+
+def asset_transform_options(preset: dict[str, Any]) -> dict[str, Any]:
+    return {key: preset[key] for key in ("width", "height", "crop", "format", "quality") if key in preset}
+
+
+def asset_transform_spec(**options: Any) -> str:
+    return _transform_spec(options)
 
 
 class AssetsClient:
@@ -25,7 +67,7 @@ class AssetsClient:
             "key": key,
             "folder": folder,
             "visibility": visibility,
-            "cacheControl": cache_control,
+            "cache_control": cache_control,
             "metadata": json.dumps(metadata) if metadata else None,
         })
 
@@ -36,21 +78,25 @@ class AssetsClient:
     def get(self, asset_id: str) -> dict[str, Any]:
         return self._client.request("GET", f"/assets/{asset_id}")
 
-    def delete(self, asset_id: str) -> dict[str, Any]:
-        return self._client.request("DELETE", f"/assets/{asset_id}")
+    def delete(self, asset_id: str, revision: int, *, idempotency_key: str | None = None) -> dict[str, Any]:
+        headers = {"If-Match": f'"{revision}"'}
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        return self._client.request("DELETE", f"/assets/{asset_id}", headers=headers)
 
     def replace(
         self,
         asset_id: str,
+        revision: int,
         file: str | Path | BinaryIO,
         *,
         cache_control: str | None = None,
         metadata: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         return self._multipart("PUT", f"/assets/{asset_id}/replace", file, {
-            "cacheControl": cache_control,
+            "cache_control": cache_control,
             "metadata": json.dumps(metadata) if metadata else None,
-        })
+        }, headers={"If-Match": f'"{revision}"'})
 
     def signed_url(
         self,
@@ -60,18 +106,259 @@ class AssetsClient:
         max_downloads: int | None = None,
     ) -> dict[str, Any]:
         return self._client.request("POST", f"/assets/{asset_id}/signed-url", json={
-            "expiresIn": expires_in,
-            "maxDownloads": max_downloads,
+            "expires_in": expires_in,
+            "max_downloads": max_downloads,
         })
 
     def signed_upload_url(self, **payload: Any) -> dict[str, Any]:
         return self.create_upload_session(**payload)
 
     def create_upload_session(self, **payload: Any) -> dict[str, Any]:
+        idempotency_key = payload.pop("idempotency_key", None)
         clean = {key: value for key, value in payload.items() if value not in (None, "")}
-        return self._client.request("POST", "/assets/upload-sessions", json=clean)
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self._client.request("POST", "/assets/upload-sessions", json=clean, headers=headers)
+
+    def create_chunked_upload_session(self, **payload: Any) -> dict[str, Any]:
+        return self.create_upload_session(mode="chunked", **payload)
+
+    def upload_chunk(
+        self,
+        upload_url_or_token: str,
+        part_number: int,
+        chunk: bytes | BinaryIO,
+    ) -> dict[str, Any]:
+        target = upload_url_or_token.rstrip("/")
+        if not target.startswith("http"):
+            origin = self._client.base_url.removesuffix("/api/v1")
+            target = f"{origin}/uploads/{quote(upload_url_or_token)}"
+
+        raw = chunk if isinstance(chunk, bytes) else chunk.read()
+        response = self._client.session.put(
+            f"{target}/parts/{part_number}",
+            data=raw,
+            headers={"User-Agent": "StackShift-Python/0.1", "X-Content-SHA256": hashlib.sha256(raw).hexdigest()},
+        )
+        payload = response.json() if response.content else None
+        if response.status_code < 200 or response.status_code >= 300:
+            message = payload.get("message") if isinstance(payload, dict) else None
+            raise RuntimeError(message or f"StackShift upload failed with {response.status_code}")
+        return payload["data"] if isinstance(payload, dict) and "data" in payload else payload
+
+    def resume_upload_session(self, session_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/upload-sessions/{session_id}")
+
+    def complete_upload_session(self, session_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/upload-sessions/{session_id}/complete")
+
+    def cancel_upload_session(self, session_id: str) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/upload-sessions/{session_id}")
+
+    def list_buckets(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/buckets")
+
+    def create_bucket(self, **payload: Any) -> dict[str, Any]:
+        return self._client.request("POST", "/assets/buckets", json=payload)
+
+    def update_bucket(self, bucket_id: str, revision: int, **payload: Any) -> dict[str, Any]:
+        return self._client.request("PUT", f"/assets/buckets/{bucket_id}", json=payload, headers={"If-Match": f'"{revision}"'})
+
+    def delete_bucket(self, bucket_id: str, revision: int) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/buckets/{bucket_id}", headers={"If-Match": f'"{revision}"'})
+
+    def set_tags(self, asset_id: str, revision: int, tags: list[str]) -> dict[str, Any]:
+        return self._client.request("PUT", f"/assets/{asset_id}/tags", json={"tags": tags}, headers={"If-Match": f'"{revision}"'})
+
+    def patch_metadata(self, asset_id: str, revision: int, metadata: dict[str, Any]) -> dict[str, Any]:
+        return self._client.request("PATCH", f"/assets/{asset_id}/metadata", json={"metadata": metadata}, headers={"If-Match": f'"{revision}"'})
+
+    def patch(self, asset_id: str, revision: int, **payload: Any) -> dict[str, Any]:
+        return self._client.request("PATCH", f"/assets/{asset_id}", json=payload, headers={"If-Match": f'"{revision}"'})
+
+    def url(self, asset_id: str, **options: Any) -> str:
+        spec = _transform_spec(options)
+        return f"{self._client.cdn_base_url}/assets/{quote(asset_id)}/tr/{quote(spec)}"
+
+    def named_url(self, asset_id: str, name: str) -> str:
+        return f"{self._client.cdn_base_url}/t/{quote(name)}/assets/{quote(asset_id)}"
+
+    def version_url(self, asset_id: str, version_id: str, token: str | None = None) -> str:
+        prefix = "/private/assets" if token else "/assets"
+        result = f"{self._client.cdn_base_url}{prefix}/{quote(asset_id)}/versions/{quote(version_id)}"
+        return f"{result}?token={quote(token)}" if token else result
+
+    def branch_url(self, asset_id: str, branch: str, token: str | None = None) -> str:
+        prefix = "/private/assets" if token else "/assets"
+        result = f"{self._client.cdn_base_url}{prefix}/{quote(asset_id)}/branches/{quote(branch)}"
+        return f"{result}?token={quote(token)}" if token else result
+
+    def video_url(self, asset_id: str, kind: str, profile: str = "default", token: str | None = None) -> str:
+        prefix = "/private/assets" if token else "/assets"
+        result = f"{self._client.cdn_base_url}{prefix}/{quote(asset_id)}/video/{quote(kind)}/{quote(profile)}"
+        return f"{result}?token={quote(token)}" if token else result
+
+    def ai(self, asset_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/{asset_id}/ai")
+
+    def request_ai_analyze(self, asset_id: str, *, idempotency_key: str | None = None) -> dict[str, Any]:
+        return self._request_ai_job(f"/assets/{asset_id}/ai/analyze", idempotency_key)
+
+    def request_moderation(self, asset_id: str, *, idempotency_key: str | None = None) -> dict[str, Any]:
+        return self._request_ai_job(f"/assets/{asset_id}/moderation", idempotency_key)
+
+    def transcript(self, asset_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/{asset_id}/transcript")
+
+    def request_transcript(self, asset_id: str, *, idempotency_key: str | None = None) -> dict[str, Any]:
+        return self._request_ai_job(f"/assets/{asset_id}/transcript", idempotency_key)
+
+    def request_smart_crop(self, asset_id: str, *, idempotency_key: str | None = None) -> dict[str, Any]:
+        return self._request_ai_job(f"/assets/{asset_id}/smart-crop", idempotency_key)
+
+    def request_background_removal(self, asset_id: str, *, idempotency_key: str | None = None) -> dict[str, Any]:
+        return self._request_ai_job(f"/assets/{asset_id}/background-remove", idempotency_key)
+
+    def _request_ai_job(self, path: str, idempotency_key: str | None) -> dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self._client.request("POST", path, headers=headers)
+
+    def versions(self, asset_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/{asset_id}/versions")
+
+    def create_branch(
+        self,
+        asset_id: str,
+        name: str,
+        from_version_id: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {"name": name, "from_version_id": from_version_id}
+        clean = {key: value for key, value in payload.items() if value not in (None, "")}
+        return self._client.request("POST", f"/assets/{asset_id}/branches", json=clean)
+
+    def restore_version(self, asset_id: str, version_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/{asset_id}/versions/{version_id}/restore")
+
+    def promote_branch(self, asset_id: str, branch: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/{asset_id}/branches/{quote(branch)}/promote")
 
-    def _multipart(self, method: str, suffix: str, file: str | Path | BinaryIO, fields: dict[str, Any]) -> dict[str, Any]:
+    def collections(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/collections")
+
+    def create_collection(self, **payload: Any) -> dict[str, Any]:
+        clean = {key: value for key, value in payload.items() if value not in (None, "")}
+        return self._client.request("POST", "/assets/collections", json=clean)
+
+    def update_collection(self, collection_id: str, **payload: Any) -> dict[str, Any]:
+        clean = {key: value for key, value in payload.items() if value not in (None, "")}
+        return self._client.request("PUT", f"/assets/collections/{collection_id}", json=clean)
+
+    def delete_collection(self, collection_id: str) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/collections/{collection_id}")
+
+    def saved_searches(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/saved-searches")
+
+    def save_search(self, **payload: Any) -> dict[str, Any]:
+        clean = {key: value for key, value in payload.items() if value not in (None, "")}
+        return self._client.request("POST", "/assets/saved-searches", json=clean)
+
+    def update_saved_search(self, search_id: str, **payload: Any) -> dict[str, Any]:
+        clean = {key: value for key, value in payload.items() if value not in (None, "")}
+        return self._client.request("PUT", f"/assets/saved-searches/{search_id}", json=clean)
+
+    def delete_saved_search(self, search_id: str) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/saved-searches/{search_id}")
+
+    def get_policy(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/policy")
+
+    def update_policy(self, **payload: Any) -> dict[str, Any]:
+        clean = {key: value for key, value in payload.items() if value not in (None, "")}
+        return self._client.request("PUT", "/assets/policy", json=clean)
+
+    def create_transformation(self, name: str, **options: Any) -> dict[str, Any]:
+        payload = {"name": name, **options}
+        clean = {key: value for key, value in payload.items() if value not in (None, "")}
+        return self._client.request("POST", "/assets/transformations", json=clean)
+
+    def list_transformations(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/transformations")
+
+    def delete_transformation(self, name: str) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/transformations/{quote(name)}")
+
+    def signed_transform_url(self, asset_id: str, **options: Any) -> dict[str, Any]:
+        clean = {key: value for key, value in options.items() if value not in (None, "")}
+        return self._client.request("POST", f"/assets/{asset_id}/transform-url", json=clean)
+
+    def get_ai_config(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/ai/config")
+
+    def update_ai_config(self, revision: int, *, enabled_actions: list[str], monthly_spend_cap_micros: int) -> dict[str, Any]:
+        return self._client.request("PUT", "/assets/ai/config", headers={"If-Match": f'"{revision}"'}, json={
+            "enabled_actions": enabled_actions,
+            "monthly_spend_cap_micros": monthly_spend_cap_micros,
+        })
+
+    def job(self, job_id: str) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/jobs/{quote(job_id)}")
+
+    def cancel_job(self, job_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/jobs/{quote(job_id)}/cancel")
+
+    def create_lifecycle_rule(self, **payload: Any) -> dict[str, Any]:
+        return self._client.request("POST", "/assets/lifecycle-rules", json=payload)
+
+    def list_lifecycle_rules(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/lifecycle-rules")
+
+    def delete_lifecycle_rule(self, rule_id: str) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/lifecycle-rules/{quote(rule_id)}")
+
+    def create_domain(self, domain: str) -> dict[str, Any]:
+        return self._client.request("POST", "/assets/domains", json={"domain": domain})
+
+    def list_domains(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/domains")
+
+    def verify_domain(self, domain_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/domains/{quote(domain_id)}/verify")
+
+    def delete_domain(self, domain_id: str) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/domains/{quote(domain_id)}")
+
+    def analytics(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/analytics")
+
+    def usage_summary(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/summary")
+
+    def events(self, limit: int = 50) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/events", params={"limit": limit})
+
+    def create_webhook(self, url: str, event_types: list[str] | None = None) -> dict[str, Any]:
+        return self._client.request("POST", "/assets/webhooks", json={"url": url, "event_types": event_types or ["asset.*"]})
+
+    def list_webhooks(self) -> dict[str, Any]:
+        return self._client.request("GET", "/assets/webhooks")
+
+    def delete_webhook(self, webhook_id: str) -> dict[str, Any]:
+        return self._client.request("DELETE", f"/assets/webhooks/{quote(webhook_id)}")
+
+    def list_webhook_deliveries(self, webhook_id: str, limit: int = 50) -> dict[str, Any]:
+        return self._client.request("GET", f"/assets/webhooks/{quote(webhook_id)}/deliveries", params={"limit": limit})
+
+    def retry_webhook_delivery(self, delivery_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/webhook-deliveries/{quote(delivery_id)}/retry")
+
+    def purge(self, asset_id: str) -> dict[str, Any]:
+        return self._client.request("POST", f"/assets/{quote(asset_id)}/purge")
+
+    def bulk(self, *, action: str, items: list[dict[str, Any]], idempotency_key: str | None = None, **payload: Any) -> dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return self._client.request("POST", "/assets/bulk", json={"action": action, "items": items, **payload}, headers=headers)
+
+    def _multipart(self, method: str, suffix: str, file: str | Path | BinaryIO, fields: dict[str, Any], headers: dict[str, str] | None = None) -> dict[str, Any]:
         should_close = False
         if isinstance(file, (str, Path)):
             handle = Path(file).open("rb")
@@ -83,7 +370,21 @@ class AssetsClient:
 
         try:
             data = {key: value for key, value in fields.items() if value not in (None, "")}
-            return self._client.request(method, suffix, data=data, files={"file": (filename, handle)})
+            return self._client.request(method, suffix, data=data, files={"file": (filename, handle)}, headers=headers)
         finally:
             if should_close:
                 handle.close()
+
+
+def _transform_spec(options: dict[str, Any]) -> str:
+    parts: list[str] = []
+    if options.get("width"):
+        parts.append(f"w_{options['width']}")
+    if options.get("height"):
+        parts.append(f"h_{options['height']}")
+    parts.append(f"c_{options.get('crop') or 'fit'}")
+    parts.append(f"f_{options.get('format') or 'auto'}")
+    parts.append(f"q_{options.get('quality') or 'auto'}")
+    parts.append(f"g_{options.get('gravity') or 'centre'}")
+    parts.append(f"a_{options.get('animation') or 'first'}")
+    return ",".join(parts)

stackshift/client.py

@@ -12,6 +12,8 @@ class StackShift:
         *,
         api_key: str | None = None,
         base_url: str = "https://api.stackshift.cloud/api/v1",
+        mail_base_url: str = "https://api.stackshift.cloud/v1",
+        cdn_base_url: str = "https://cdn.stackshift.cloud",
         session: requests.Session | None = None,
     ) -> None:
         api_key = api_key or os.getenv("STACKSHIFT_API_KEY")
@@ -20,25 +22,58 @@ class StackShift:
 
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
+        self.mail_base_url = mail_base_url.rstrip("/")
+        self.cdn_base_url = cdn_base_url.rstrip("/")
         self.session = session or requests.Session()
 
         from .assets import AssetsClient
+        from .mail import MailClient
         from .projects import ProjectsClient
 
         self.projects = ProjectsClient(self)
         self.assets = AssetsClient(self)
+        self.mail = MailClient(self)
 
     def request(self, method: str, path: str, **kwargs: Any) -> Any:
+        return self._request(self.base_url, method, path, **kwargs)
+
+    def mail_request(self, method: str, path: str, **kwargs: Any) -> Any:
+        return self._request(self.mail_base_url, method, path, **kwargs)
+
+    def _request(self, base_url: str, method: str, path: str, **kwargs: Any) -> Any:
         headers = kwargs.pop("headers", {})
         headers["Authorization"] = f"Bearer {self.api_key}"
         headers["User-Agent"] = "StackShift-Python/0.1"
 
-        response = self.session.request(method, f"{self.base_url}{path}", headers=headers, **kwargs)
+        response = self.session.request(method, f"{base_url}{path}", headers=headers, **kwargs)
         payload = response.json() if response.content else None
         if response.status_code < 200 or response.status_code >= 300:
+            error = payload.get("error") if isinstance(payload, dict) else None
+            if isinstance(error, dict):
+                raise StackShiftAPIError(
+                    error.get("message") or f"StackShift API request failed with {response.status_code}",
+                    status_code=response.status_code,
+                    code=error.get("code"),
+                    details=error.get("details"),
+                )
             message = payload.get("message") if isinstance(payload, dict) else None
-            raise RuntimeError(message or f"StackShift API request failed with {response.status_code}")
+            raise StackShiftAPIError(message or f"StackShift API request failed with {response.status_code}", status_code=response.status_code)
 
         if isinstance(payload, dict) and "success" in payload and "data" in payload:
             return payload["data"]
         return payload
+
+
+class StackShiftAPIError(RuntimeError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int,
+        code: str | None = None,
+        details: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+        self.details = details

stackshift/mail.py

@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from .mail_advanced import MailAnalyticsClient, MailBatchClient, MailInboundClient, MailScheduledClient
+from .mail_phase7 import MailEventsClient, MailWebhooksClient
+from .mail_reputation import MailLimitsClient, MailReputationClient
+
+
+class MailClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+        self.domains = MailDomainsClient(client)
+        self.messages = MailMessagesClient(client)
+        self.suppressions = MailSuppressionsClient(client)
+        self.bounces = MailBouncesClient(client)
+        self.otp = MailOTPClient(client)
+        self.templates = MailTemplatesClient(client)
+        self.events = MailEventsClient(client)
+        self.webhooks = MailWebhooksClient(client)
+        self.limits = MailLimitsClient(client)
+        self.reputation = MailReputationClient(client)
+        self.scheduled = MailScheduledClient(client)
+        self.batch = MailBatchClient(client)
+        self.inbound = MailInboundClient(client)
+        self.analytics = MailAnalyticsClient(client)
+
+    def send(
+        self,
+        *,
+        from_: str | dict[str, str],
+        to: str | list[str] | list[dict[str, str]],
+        subject: str,
+        html: str | None = None,
+        text: str | None = None,
+        cc: str | list[str] | list[dict[str, str]] | None = None,
+        bcc: str | list[str] | list[dict[str, str]] | None = None,
+        reply_to: str | dict[str, str] | None = None,
+        idempotency_key: str | None = None,
+        attachments: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        payload = {
+            "from": from_,
+            "to": to,
+            "cc": cc,
+            "bcc": bcc,
+            "replyTo": reply_to,
+            "subject": subject,
+            "html": html,
+            "text": text,
+            "idempotencyKey": idempotency_key,
+            "attachments": attachments,
+        }
+        clean = {key: value for key, value in payload.items() if value is not None}
+        return self._client.mail_request("POST", "/mail/send", json=clean)
+
+    def send_template(
+        self,
+        *,
+        template: str,
+        to: str | list[str] | list[dict[str, str]],
+        data: dict[str, Any],
+        from_: str | dict[str, str] | None = None,
+        version_id: str | None = None,
+        cc: str | list[str] | list[dict[str, str]] | None = None,
+        bcc: str | list[str] | list[dict[str, str]] | None = None,
+        reply_to: str | dict[str, str] | None = None,
+        idempotency_key: str | None = None,
+        attachments: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        payload = {
+            "template": template,
+            "versionId": version_id,
+            "to": to,
+            "from": from_,
+            "cc": cc,
+            "bcc": bcc,
+            "replyTo": reply_to,
+            "data": data,
+            "idempotencyKey": idempotency_key,
+            "attachments": attachments,
+        }
+        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)
+
+
+class MailTemplatesClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        name: str,
+        slug: str,
+        subject: str,
+        description: str | None = None,
+        html: str | None = None,
+        text: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {
+            "name": name,
+            "slug": slug,
+            "description": description,
+            "subject": subject,
+            "html": html,
+            "text": text,
+        }
+        clean = {key: value for key, value in payload.items() if value is not None}
+        return self._client.mail_request("POST", "/mail/templates", json=clean)
+
+    def list(
+        self,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        search: str | None = None,
+    ) -> dict[str, Any]:
+        params = {"status": status, "limit": limit, "cursor": cursor, "search": search}
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/templates", params=clean)
+
+    def get(self, template_id_or_slug: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/templates/{quote(template_id_or_slug)}")
+
+    def update(
+        self,
+        template_id: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+        subject: str | None = None,
+        html: str | None = None,
+        text: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {
+            "name": name,
+            "description": description,
+            "subject": subject,
+            "html": html,
+            "text": text,
+        }
+        clean = {key: value for key, value in payload.items() if value is not None}
+        return self._client.mail_request("PATCH", f"/mail/templates/{quote(template_id)}", json=clean)
+
+    def delete(self, template_id: str) -> None:
+        self._client.mail_request("DELETE", f"/mail/templates/{quote(template_id)}")
+
+    def versions(self, template_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/templates/{quote(template_id)}/versions")
+
+    def get_version(self, template_id: str, version_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/templates/{quote(template_id)}/versions/{quote(version_id)}")
+
+    def activate_version(self, template_id: str, version_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/templates/{quote(template_id)}/versions/{quote(version_id)}/activate")
+
+    def preview(self, template_id: str, *, data: dict[str, Any], version_id: str | None = None) -> dict[str, Any]:
+        payload = {"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)}/preview", json=clean)
+
+    def test_send(
+        self,
+        template_id: str,
+        *,
+        to: str | list[str] | list[dict[str, str]],
+        data: dict[str, Any],
+        from_: str | dict[str, str] | None = None,
+        version_id: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {"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)
+
+
+class MailDomainsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(self, domain: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", "/mail/domains", json={"domain": domain})
+
+    def list(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/domains")
+
+    def get(self, domain_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/domains/{quote(domain_id)}")
+
+    def verify(self, domain_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/domains/{quote(domain_id)}/verify")
+
+    def delete(self, domain_id: str) -> None:
+        self._client.mail_request("DELETE", f"/mail/domains/{quote(domain_id)}")
+
+
+class MailMessagesClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        to: str | None = None,
+        from_: str | None = None,
+    ) -> dict[str, Any]:
+        params = {
+            "status": status,
+            "limit": limit,
+            "cursor": cursor,
+            "to": to,
+            "from": from_,
+        }
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/messages", params=clean)
+
+    def get(self, message_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/messages/{quote(message_id)}")
+
+    def attempts(self, message_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/messages/{quote(message_id)}/attempts")
+
+    def logs(self, message_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/messages/{quote(message_id)}/logs")
+
+    def bounces(self, message_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/messages/{quote(message_id)}/bounces")
+
+    def timeline(self, message_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/messages/{quote(message_id)}/timeline")
+
+
+class MailSuppressionsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        email: str | None = None,
+        reason: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        params = {
+            "email": email,
+            "reason": reason,
+            "limit": limit,
+            "cursor": cursor,
+        }
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/suppressions", params=clean)
+
+    def create(
+        self,
+        *,
+        email: str,
+        reason: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        payload = {
+            "email": email,
+            "reason": reason,
+            "metadata": metadata,
+        }
+        clean = {key: value for key, value in payload.items() if value is not None}
+        return self._client.mail_request("POST", "/mail/suppressions", json=clean)
+
+    def delete(self, suppression_id: str) -> None:
+        self._client.mail_request("DELETE", f"/mail/suppressions/{quote(suppression_id)}")
+
+
+class MailBouncesClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        email: str | None = None,
+        type: str | None = None,
+        message_id: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        params = {
+            "email": email,
+            "type": type,
+            "messageId": message_id,
+            "limit": limit,
+            "cursor": cursor,
+        }
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/bounces", params=clean)
+
+
+class MailOTPClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+        self.challenges = MailOTPChallengesClient(client)
+
+    def send(
+        self,
+        *,
+        to: str,
+        purpose: str,
+        from_: str | None = None,
+        expires_in: str | None = None,
+        code_length: int | None = None,
+        metadata: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+        subject: str | None = None,
+        brand_name: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {
+            "to": to,
+            "purpose": purpose,
+            "from": from_,
+            "expiresIn": expires_in,
+            "codeLength": code_length,
+            "metadata": metadata,
+            "idempotencyKey": idempotency_key,
+            "subject": subject,
+            "brandName": brand_name,
+        }
+        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)
+
+    def verify(
+        self,
+        *,
+        code: str,
+        to: str | None = None,
+        purpose: str | None = None,
+        challenge_id: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {
+            "to": to,
+            "purpose": purpose,
+            "challengeId": challenge_id,
+            "code": code,
+        }
+        clean = {key: value for key, value in payload.items() if value is not None}
+        return self._client.mail_request("POST", "/mail/otp/verify", json=clean)
+
+
+class MailOTPChallengesClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        to: str | None = None,
+        purpose: str | None = None,
+        status: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        params = {
+            "to": to,
+            "purpose": purpose,
+            "status": status,
+            "limit": limit,
+            "cursor": cursor,
+        }
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/otp/challenges", params=clean)
+
+    def get(self, challenge_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/otp/challenges/{quote(challenge_id)}")
+
+    def cancel(self, challenge_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/otp/challenges/{quote(challenge_id)}/cancel")

stackshift/mail_advanced.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+
+class MailScheduledClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(self, **payload: Any) -> dict[str, Any]:
+        clean = {key: value for key, value in payload.items() if value is not None}
+        return self._client.mail_request("POST", "/mail/scheduled", json=clean)
+
+    def list(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/scheduled")
+
+    def get(self, scheduled_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/scheduled/{quote(scheduled_id)}")
+
+    def cancel(self, scheduled_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/scheduled/{quote(scheduled_id)}/cancel")
+
+
+class MailBatchClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def send(self, *, from_: str | dict[str, str], messages: list[dict[str, Any]]) -> dict[str, Any]:
+        return self._client.mail_request("POST", "/mail/batch", json={"from": from_, "messages": messages})
+
+    def send_template(
+        self,
+        *,
+        template: str,
+        from_: str | dict[str, str],
+        recipients: list[dict[str, Any]],
+        version_id: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {"template": template, "from": from_, "recipients": recipients, "versionId": version_id}
+        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)
+
+
+class MailInboundClient:
+    def __init__(self, client: Any) -> None:
+        self.domains = MailInboundDomainsClient(client)
+        self.messages = MailInboundMessagesClient(client)
+
+
+class MailInboundDomainsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(self, domain: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", "/mail/inbound/domains", json={"domain": domain})
+
+    def list(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/inbound/domains")
+
+    def verify(self, domain_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/inbound/domains/{quote(domain_id)}/verify")
+
+
+class MailInboundMessagesClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def list(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/inbound/messages")
+
+    def get(self, message_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/inbound/messages/{quote(message_id)}")
+
+
+class MailAnalyticsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def get(
+        self,
+        *,
+        range_: str | None = None,
+        from_: str | None = None,
+        to: str | None = None,
+        interval: str | None = None,
+        domain: str | None = None,
+        template: str | None = None,
+        event: str | None = None,
+    ) -> dict[str, Any]:
+        params = {
+            "range": range_,
+            "from": from_,
+            "to": to,
+            "interval": interval,
+            "domain": domain,
+            "template": template,
+            "event": event,
+        }
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/analytics", params=clean)

stackshift/mail_phase7.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+import time
+from typing import Any
+from urllib.parse import quote
+
+
+class MailEventsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        type: str | None = None,
+        resource_type: str | None = None,
+        resource_id: str | None = None,
+        message_id: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> dict[str, Any]:
+        params = {
+            "type": type,
+            "resourceType": resource_type,
+            "resourceId": resource_id,
+            "messageId": message_id,
+            "limit": limit,
+            "cursor": cursor,
+            "from": from_,
+            "to": to,
+        }
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/events", params=clean)
+
+    def get(self, event_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/events/{quote(event_id)}")
+
+
+class MailWebhooksClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        url: str,
+        event_types: list[str],
+        description: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {"url": url, "description": description, "eventTypes": event_types}
+        clean = {key: value for key, value in payload.items() if value is not None}
+        return self._client.mail_request("POST", "/mail/webhooks", json=clean)
+
+    def list(self, *, limit: int | None = None, cursor: str | None = None) -> dict[str, Any]:
+        params = {"limit": limit, "cursor": cursor}
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/webhooks", params=clean)
+
+    def get(self, webhook_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/webhooks/{quote(webhook_id)}")
+
+    def update(
+        self,
+        webhook_id: str,
+        *,
+        url: str | None = None,
+        description: str | None = None,
+        event_types: list[str] | None = None,
+        status: str | None = None,
+    ) -> dict[str, Any]:
+        payload = {"url": url, "description": description, "eventTypes": event_types, "status": status}
+        clean = {key: value for key, value in payload.items() if value is not None}
+        return self._client.mail_request("PATCH", f"/mail/webhooks/{quote(webhook_id)}", json=clean)
+
+    def rotate_secret(self, webhook_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/webhooks/{quote(webhook_id)}/rotate-secret")
+
+    def delete(self, webhook_id: str) -> None:
+        self._client.mail_request("DELETE", f"/mail/webhooks/{quote(webhook_id)}")
+
+    def deliveries(
+        self,
+        webhook_id: str,
+        *,
+        status: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        params = {"status": status, "limit": limit, "cursor": cursor}
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", f"/mail/webhooks/{quote(webhook_id)}/deliveries", params=clean)
+
+    def get_delivery(self, delivery_id: str) -> dict[str, Any]:
+        return self._client.mail_request("GET", f"/mail/webhook-deliveries/{quote(delivery_id)}")
+
+    def retry_delivery(self, delivery_id: str) -> dict[str, Any]:
+        return self._client.mail_request("POST", f"/mail/webhook-deliveries/{quote(delivery_id)}/retry")
+
+    def verify_signature(
+        self,
+        *,
+        raw_body: bytes | str,
+        signature_header: str | None,
+        timestamp_header: str | None,
+        secret: str,
+        tolerance_seconds: int = 300,
+        now: int | None = None,
+    ) -> bool:
+        return verify_webhook_signature(
+            raw_body=raw_body,
+            signature_header=signature_header,
+            timestamp_header=timestamp_header,
+            secret=secret,
+            tolerance_seconds=tolerance_seconds,
+            now=now,
+        )
+
+
+def verify_webhook_signature(
+    *,
+    raw_body: bytes | str,
+    signature_header: str | None,
+    timestamp_header: str | None,
+    secret: str,
+    tolerance_seconds: int = 300,
+    now: int | None = None,
+) -> bool:
+    if not raw_body or not signature_header or not timestamp_header or not secret:
+        return False
+    try:
+        timestamp = int(timestamp_header)
+    except ValueError:
+        return False
+    current = int(time.time()) if now is None else int(now)
+    if abs(current - timestamp) > tolerance_seconds:
+        return False
+    body = raw_body.encode() if isinstance(raw_body, str) else raw_body
+    signed = timestamp_header.encode() + b"." + body
+    expected = hmac.new(secret.encode(), signed, hashlib.sha256).hexdigest()
+    provided = _signature_v1(signature_header)
+    return bool(provided) and hmac.compare_digest(expected, provided)
+
+
+def _signature_v1(header: str) -> str:
+    for part in header.split(","):
+        key, _, value = part.strip().partition("=")
+        if key == "v1":
+            return value
+    return ""

stackshift/mail_reputation.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class MailLimitsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def get(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/limits")
+
+
+class MailReputationClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+        self.events = MailReputationEventsClient(client)
+
+    def get(self) -> dict[str, Any]:
+        return self._client.mail_request("GET", "/mail/reputation")
+
+
+class MailReputationEventsClient:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        severity: str | None = None,
+        type: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        params = {"severity": severity, "type": type, "limit": limit, "cursor": cursor}
+        clean = {key: value for key, value in params.items() if value not in (None, "")}
+        return self._client.mail_request("GET", "/mail/reputation/events", params=clean)
+

{stackshift-0.1.0.dist-info → stackshift-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackshift
-Version: 0.1.0
+Version: 0.1.2
 Summary: Official Python SDK for StackShift.
 Requires-Python: >=3.9
 Requires-Dist: requests>=2.31

stackshift-0.1.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+stackshift/__init__.py,sha256=e5QZUzE6m_195Cvvawyv8p_M18eNkQzW6sBgBn3SlRo,1008
+stackshift/assets.py,sha256=qRzL9BNZSneNBc3es_vLsY4_hh_r3zOfdO_rAKQq5LU,22949
+stackshift/client.py,sha256=AcJivv4VRCQ756MRrxCrLi0Q4in-4np0Re8ceQSTF1Y,3000
+stackshift/mail.py,sha256=vegCniMcWBvHtz_UGAfNfVxFYTety8H3KKFQsWfKZSs,13462
+stackshift/mail_advanced.py,sha256=-lzajXqlrkR8qA4YpRX5Sv3VwcEQITtKfIXbWwjRRQE,3533
+stackshift/mail_phase7.py,sha256=Ud2fyKwt-vpaw7vgEayLw5q9tiDIF-fkfTBaoGJMJBI,5377
+stackshift/mail_reputation.py,sha256=mPvPkZeqcQc5808PhBK7gYsgf4Fk_U19nRxSsJ60MGU,1112
+stackshift/projects.py,sha256=oYWaE7xNRR6OXuPEwJH-oFFeOmDA9ozq6jJY09ANIHA,498
+stackshift-0.1.2.dist-info/METADATA,sha256=GKbdBmBmZWOUs8DTe-amYxZNbplrh7pAlkaRtkBWQ14,152
+stackshift-0.1.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+stackshift-0.1.2.dist-info/top_level.txt,sha256=qe3uWsu_O9mNtq7bIck9Y8rjTIMrH0kzgAlGFDoRGqs,11
+stackshift-0.1.2.dist-info/RECORD,,

{stackshift-0.1.0.dist-info → stackshift-0.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

stackshift-0.1.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-stackshift/__init__.py,sha256=Z0Q6SrKZyIx-YBt5pdIVXgnJGF4TeBYKtUA7vdxKlU4,161
-stackshift/assets.py,sha256=qvu1qXd5wJqeWc4hpdGYcorXXMtZUNEwjlaT61lu7-A,3119
-stackshift/client.py,sha256=YM9xgy0145f37l8x6A-Ecrg9zw5Z1E6DTRKEdiQ0P4g,1566
-stackshift/projects.py,sha256=oYWaE7xNRR6OXuPEwJH-oFFeOmDA9ozq6jJY09ANIHA,498
-stackshift-0.1.0.dist-info/METADATA,sha256=M9M2rhNT9c7bNRMCQkRTQ-Db8mYZ7T_Ccxva3KXCnq8,152
-stackshift-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-stackshift-0.1.0.dist-info/top_level.txt,sha256=qe3uWsu_O9mNtq7bIck9Y8rjTIMrH0kzgAlGFDoRGqs,11
-stackshift-0.1.0.dist-info/RECORD,,