zazu-sdk 0.2.1__tar.gz

zazu_sdk-0.2.1/.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.venv/
+venv/
+dist/
+build/
+.coverage
+htmlcov/
+.env
+tests/fixtures/cassettes/
+cassettes-v*.tar.gz
+.tox/
+.python-version.local

zazu_sdk-0.2.1/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to `zazu-sdk` are documented here.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.1]
+
+Version alignment: the whole SDK family now releases in lockstep with zazu-ruby. No functional changes since [0.1.0].
+
+## [0.1.0]
+
+Initial release.
+
+### Added
+
+- Sync `Zazu` client built on `httpx`
+- Resource modules: `accounts`, `beneficiaries`, `checkout_sessions`, `customers`, `entity`, `invoices`, `payment_links`, `transfer_drafts`, `webhook_endpoints`
+- Cursor-based `Page` with `auto_paging_iter()`
+- Nine-class error hierarchy mirroring `zazu-ruby`
+- Cassette-replay test harness driven by the Ruby SDK's release tarball

zazu_sdk-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zazu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zazu_sdk-0.2.1/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: zazu-sdk
+Version: 0.2.1
+Summary: Python SDK for the Zazu API.
+Project-URL: Homepage, https://github.com/getzazu/zazu-python
+Project-URL: Documentation, https://github.com/getzazu/zazu-python#readme
+Project-URL: Repository, https://github.com/getzazu/zazu-python
+Project-URL: Issues, https://github.com/getzazu/zazu-python/issues
+Project-URL: Changelog, https://github.com/getzazu/zazu-python/blob/main/CHANGELOG.md
+Author-email: Zazu <engineering@zazu.ma>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,fintech,morocco,sdk,zazu
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-vcr>=1.0.2; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.7; extra == 'dev'
+Requires-Dist: vcrpy>=6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# zazu-sdk
+
+Python SDK for the [Zazu API](https://zazu.ma).
+
+## Install
+
+```bash
+pip install zazu-sdk
+```
+
+Requires Python 3.11+.
+
+## Quick start
+
+```python
+from zazu_sdk import Zazu
+
+client = Zazu(api_key="sk_live_...")
+
+client.entity.get()
+client.accounts.list(currency_code="MAD")
+client.customers.list(q="Acme")
+client.customers.create(
+    customer_type="business",
+    company_name="Acme Corp",
+    email="billing@acme.com",
+)
+
+client.invoices.list()
+client.payment_links.cancel(payment_link_id)
+client.webhook_endpoints.list()
+
+client.checkout_sessions.create(
+    account_id=account_id,
+    amount="100.00",
+    success_url="https://example.com/ok",
+    cancel_url="https://example.com/cancel",
+)
+client.checkout_sessions.get(session_id)
+```
+
+The client picks up `ZAZU_API_KEY`, `ZAZU_BASE_URL`, `ZAZU_API_VERSION`, and
+`ZAZU_TIMEOUT` from the environment if you don't pass them.
+
+## Pagination
+
+List endpoints return a `Page`. Iterate one page or chase cursors:
+
+```python
+page = client.invoices.list(limit=25)
+for invoice in page:
+    ...
+
+# All items, automatic cursor chasing:
+for invoice in client.invoices.list().auto_paging_iter():
+    ...
+```
+
+## Errors
+
+Nine concrete subclasses; discriminate with `isinstance`:
+
+```python
+from zazu_sdk import (
+    ZazuValidationError,
+    ZazuRateLimitError,
+    ZazuNotFoundError,
+)
+
+try:
+    client.invoices.get("nope")
+except ZazuNotFoundError as err:
+    print(err.status, err.request_id, err.body)
+except ZazuRateLimitError as err:
+    print("retry after", err.retry_after, "seconds")
+```
+
+## Cross-SDK contract
+
+`zazu-sdk` is one of several Zazu SDKs that all replay cassettes recorded by
+the canonical [`zazu-ruby`](https://github.com/getzazu/zazu-ruby) SDK against
+staging. The wire format is snake_case JSON; request and response shapes match
+across Ruby, TypeScript, Python, Go, and Rust.
+
+## License
+
+MIT.

zazu_sdk-0.2.1/README.md

@@ -0,0 +1,87 @@
+# zazu-sdk
+
+Python SDK for the [Zazu API](https://zazu.ma).
+
+## Install
+
+```bash
+pip install zazu-sdk
+```
+
+Requires Python 3.11+.
+
+## Quick start
+
+```python
+from zazu_sdk import Zazu
+
+client = Zazu(api_key="sk_live_...")
+
+client.entity.get()
+client.accounts.list(currency_code="MAD")
+client.customers.list(q="Acme")
+client.customers.create(
+    customer_type="business",
+    company_name="Acme Corp",
+    email="billing@acme.com",
+)
+
+client.invoices.list()
+client.payment_links.cancel(payment_link_id)
+client.webhook_endpoints.list()
+
+client.checkout_sessions.create(
+    account_id=account_id,
+    amount="100.00",
+    success_url="https://example.com/ok",
+    cancel_url="https://example.com/cancel",
+)
+client.checkout_sessions.get(session_id)
+```
+
+The client picks up `ZAZU_API_KEY`, `ZAZU_BASE_URL`, `ZAZU_API_VERSION`, and
+`ZAZU_TIMEOUT` from the environment if you don't pass them.
+
+## Pagination
+
+List endpoints return a `Page`. Iterate one page or chase cursors:
+
+```python
+page = client.invoices.list(limit=25)
+for invoice in page:
+    ...
+
+# All items, automatic cursor chasing:
+for invoice in client.invoices.list().auto_paging_iter():
+    ...
+```
+
+## Errors
+
+Nine concrete subclasses; discriminate with `isinstance`:
+
+```python
+from zazu_sdk import (
+    ZazuValidationError,
+    ZazuRateLimitError,
+    ZazuNotFoundError,
+)
+
+try:
+    client.invoices.get("nope")
+except ZazuNotFoundError as err:
+    print(err.status, err.request_id, err.body)
+except ZazuRateLimitError as err:
+    print("retry after", err.retry_after, "seconds")
+```
+
+## Cross-SDK contract
+
+`zazu-sdk` is one of several Zazu SDKs that all replay cassettes recorded by
+the canonical [`zazu-ruby`](https://github.com/getzazu/zazu-ruby) SDK against
+staging. The wire format is snake_case JSON; request and response shapes match
+across Ruby, TypeScript, Python, Go, and Rust.
+
+## License
+
+MIT.

zazu_sdk-0.2.1/pyproject.toml

@@ -0,0 +1,91 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "zazu-sdk"
+description = "Python SDK for the Zazu API."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "Zazu", email = "engineering@zazu.ma" }]
+keywords = ["zazu", "sdk", "api", "fintech", "morocco"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+dynamic = ["version"]
+dependencies = ["httpx>=0.27"]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8",
+  "pytest-vcr>=1.0.2",
+  "vcrpy>=6",
+  "ruff>=0.7",
+  "mypy>=1.11",
+]
+
+[project.urls]
+Homepage = "https://github.com/getzazu/zazu-python"
+Documentation = "https://github.com/getzazu/zazu-python#readme"
+Repository = "https://github.com/getzazu/zazu-python"
+Issues = "https://github.com/getzazu/zazu-python/issues"
+Changelog = "https://github.com/getzazu/zazu-python/blob/main/CHANGELOG.md"
+
+[tool.hatch.version]
+path = "src/zazu_sdk/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/zazu_sdk"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/zazu_sdk", "README.md", "CHANGELOG.md", "LICENSE"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+filterwarnings = ["error"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+  "E", "F", "W",   # pycodestyle / pyflakes
+  "I",             # isort
+  "B",             # bugbear
+  "UP",            # pyupgrade
+  "PL",            # pylint subset
+  "RUF",           # ruff-specific
+  "SIM",           # simplify
+  "TCH",           # type-checking imports
+]
+ignore = [
+  "PLR0913",  # too many args — SDK methods accept many kwargs by design
+  "PLR0911",  # too many returns — error-status dispatch is naturally a switch
+  "PLR2004",  # magic-value comparison — fine for HTTP status codes
+  "TC001",    # move application imports under TYPE_CHECKING — many are used at runtime
+  "TC002",    # move third-party imports under TYPE_CHECKING — same reason
+  "TC003",    # move stdlib imports under TYPE_CHECKING — same reason
+  "UP037",    # remove quotes from annotations — needed for `Self`-style forward refs
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["PLR2004"]
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+files = ["src/zazu_sdk"]

zazu_sdk-0.2.1/src/zazu_sdk/__init__.py

@@ -0,0 +1,57 @@
+"""Zazu Python SDK. Mirrors lib/zazu.rb."""
+
+from ._version import __version__
+from .client import Zazu
+from .errors import (
+    ZazuArgumentError,
+    ZazuAuthenticationError,
+    ZazuConfigurationError,
+    ZazuConnectionError,
+    ZazuError,
+    ZazuForbiddenError,
+    ZazuNotFoundError,
+    ZazuRateLimitError,
+    ZazuServerError,
+    ZazuValidationError,
+)
+from .page import MAX_PER_PAGE, Page
+from .resources.accounts import Accounts
+from .resources.beneficiaries import Beneficiaries
+from .resources.checkout_sessions import CheckoutSessions
+from .resources.customers import Customers
+from .resources.entity import Entity
+from .resources.invoices import Invoices
+from .resources.payment_links import PaymentLinks
+from .resources.transfer_drafts import TransferDrafts
+from .resources.webhook_endpoints import WebhookEndpoints
+from .response import ZazuResponse
+
+VERSION = __version__
+
+__all__ = [
+    "MAX_PER_PAGE",
+    "VERSION",
+    "Accounts",
+    "Beneficiaries",
+    "CheckoutSessions",
+    "Customers",
+    "Entity",
+    "Invoices",
+    "Page",
+    "PaymentLinks",
+    "TransferDrafts",
+    "WebhookEndpoints",
+    "Zazu",
+    "ZazuArgumentError",
+    "ZazuAuthenticationError",
+    "ZazuConfigurationError",
+    "ZazuConnectionError",
+    "ZazuError",
+    "ZazuForbiddenError",
+    "ZazuNotFoundError",
+    "ZazuRateLimitError",
+    "ZazuResponse",
+    "ZazuServerError",
+    "ZazuValidationError",
+    "__version__",
+]

zazu_sdk-0.2.1/src/zazu_sdk/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.1"

zazu_sdk-0.2.1/src/zazu_sdk/client.py

@@ -0,0 +1,200 @@
+"""Mirrors lib/zazu/client.rb. Sync HTTP entry point built on httpx."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+from urllib.parse import urlencode
+
+import httpx
+
+from ._version import __version__
+from .errors import (
+    ZazuAuthenticationError,
+    ZazuConfigurationError,
+    ZazuConnectionError,
+    ZazuError,
+    ZazuForbiddenError,
+    ZazuNotFoundError,
+    ZazuRateLimitError,
+    ZazuServerError,
+    ZazuValidationError,
+)
+from .page import MAX_PER_PAGE, Page
+from .resources.accounts import Accounts
+from .resources.beneficiaries import Beneficiaries
+from .resources.checkout_sessions import CheckoutSessions
+from .resources.customers import Customers
+from .resources.entity import Entity
+from .resources.invoices import Invoices
+from .resources.payment_links import PaymentLinks
+from .resources.transfer_drafts import TransferDrafts
+from .resources.webhook_endpoints import WebhookEndpoints
+from .response import ZazuResponse
+
+DEFAULT_BASE_URL = "https://zazu.ma"
+DEFAULT_TIMEOUT = 30.0
+USER_AGENT = f"zazu-sdk/{__version__}"
+
+
+class Zazu:
+    """Top-level Zazu client. Resources hang off it as attributes."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str | None = None,
+        api_version: str | None = None,
+        timeout: float | None = None,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        api_key = api_key or os.getenv("ZAZU_API_KEY")
+        if not api_key:
+            raise ZazuConfigurationError(
+                "Missing api_key. Pass api_key= or set ZAZU_API_KEY."
+            )
+        self.api_key = api_key
+        self.base_url = (base_url or os.getenv("ZAZU_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.api_version = api_version or os.getenv("ZAZU_API_VERSION")
+        self.timeout = (
+            timeout if timeout is not None else _env_float("ZAZU_TIMEOUT", DEFAULT_TIMEOUT)
+        )
+        self._owns_client = http_client is None
+        self._http = http_client or httpx.Client(timeout=self.timeout)
+
+        self.accounts = Accounts(self)
+        self.beneficiaries = Beneficiaries(self)
+        self.checkout_sessions = CheckoutSessions(self)
+        self.customers = Customers(self)
+        self.entity = Entity(self)
+        self.invoices = Invoices(self)
+        self.payment_links = PaymentLinks(self)
+        self.transfer_drafts = TransferDrafts(self)
+        self.webhook_endpoints = WebhookEndpoints(self)
+
+    def __enter__(self) -> Zazu:
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._http.close()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        body: Any = None,
+        headers: dict[str, str] | None = None,
+    ) -> ZazuResponse:
+        url = self._build_url(path, params)
+        request_headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "User-Agent": USER_AGENT,
+            "Accept": "application/json",
+        }
+        if self.api_version:
+            request_headers["Zazu-Version"] = self.api_version
+        if headers:
+            request_headers.update(headers)
+
+        request_kwargs: dict[str, Any] = {"headers": request_headers}
+        if body is not None:
+            request_headers["Content-Type"] = "application/json"
+            request_kwargs["content"] = json.dumps(body)
+
+        try:
+            raw = self._http.request(method.upper(), url, **request_kwargs)
+        except httpx.TimeoutException as err:
+            raise ZazuConnectionError(f"Request timed out after {self.timeout}s") from err
+        except httpx.HTTPError as err:
+            raise ZazuConnectionError(f"Connection failed: {err}") from err
+
+        parsed = _parse_body(raw)
+        response = ZazuResponse(raw, parsed)
+        if response.success:
+            return response
+        raise _build_error(response)
+
+    def _build_url(self, path: str, params: dict[str, Any] | None) -> str:
+        trimmed = path.lstrip("/")
+        url = f"{self.base_url}/{trimmed}"
+        if params:
+            cleaned = {k: v for k, v in params.items() if v is not None}
+            if cleaned:
+                url = f"{url}?{urlencode(cleaned, doseq=True)}"
+        return url
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.getenv(name)
+    if not raw:
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def _parse_body(raw: httpx.Response) -> Any:
+    content_type = raw.headers.get("content-type", "")
+    if "json" not in content_type:
+        return None
+    text = raw.text
+    if not text:
+        return None
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return text
+
+
+def _error_payload(body: Any) -> dict[str, Any]:
+    if not isinstance(body, dict):
+        return {}
+    err = body.get("error")
+    return err if isinstance(err, dict) else {}
+
+
+def _build_error(response: ZazuResponse) -> ZazuError:
+    payload = _error_payload(response.body)
+    message = payload.get("message")
+    opts: dict[str, Any] = {
+        "status": response.status,
+        "request_id": response.request_id,
+        "type": payload.get("type"),
+        "param": payload.get("param"),
+        "body": response.body,
+        "headers": response.headers,
+    }
+
+    status = response.status
+    if status == 401:
+        return ZazuAuthenticationError(message or "Authentication failed", **opts)
+    if status == 403:
+        return ZazuForbiddenError(message or "Forbidden", **opts)
+    if status == 404:
+        return ZazuNotFoundError(message or "Not found", **opts)
+    if status == 422:
+        return ZazuValidationError(message or "Validation failed", **opts)
+    if status == 429:
+        retry_after = response.headers.get("retry-after")
+        try:
+            retry_after_int = int(retry_after) if retry_after else None
+        except ValueError:
+            retry_after_int = None
+        return ZazuRateLimitError(
+            message or "Rate limited", retry_after=retry_after_int, **opts
+        )
+    if 500 <= status < 600:
+        return ZazuServerError(message or f"Server error ({status})", **opts)
+    return ZazuError(message or f"Unexpected status {status}", **opts)
+
+
+__all__ = ["MAX_PER_PAGE", "Page", "Zazu"]

zazu_sdk-0.2.1/src/zazu_sdk/errors.py

@@ -0,0 +1,69 @@
+"""Mirrors lib/zazu/errors.rb. Nine-class hierarchy shared across SDKs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class ZazuError(Exception):
+    """Base class for every error raised by the SDK."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int | None = None,
+        request_id: str | None = None,
+        type: str | None = None,
+        param: str | None = None,
+        body: Any = None,
+        headers: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.request_id = request_id
+        self.type = type
+        self.param = param
+        self.body = body
+        self.headers = headers
+
+
+class ZazuArgumentError(ZazuError):
+    """Caller passed bad arguments before any HTTP request was made."""
+
+
+class ZazuConfigurationError(ZazuError):
+    """Missing or invalid client configuration (e.g. no API key)."""
+
+
+class ZazuConnectionError(ZazuError):
+    """The HTTP request failed before getting a response (timeout, DNS, refused)."""
+
+
+class ZazuAuthenticationError(ZazuError):
+    """HTTP 401."""
+
+
+class ZazuForbiddenError(ZazuError):
+    """HTTP 403."""
+
+
+class ZazuNotFoundError(ZazuError):
+    """HTTP 404."""
+
+
+class ZazuValidationError(ZazuError):
+    """HTTP 422."""
+
+
+class ZazuRateLimitError(ZazuError):
+    """HTTP 429. `retry_after` is the value of the Retry-After header in seconds, if present."""
+
+    def __init__(self, message: str, *, retry_after: int | None = None, **kwargs: Any) -> None:
+        super().__init__(message, **kwargs)
+        self.retry_after = retry_after
+
+
+class ZazuServerError(ZazuError):
+    """HTTP 5xx."""

zazu_sdk-0.2.1/src/zazu_sdk/page.py

@@ -0,0 +1,54 @@
+"""Mirrors lib/zazu/page.rb. Cursor-based pagination, hard cap of 100 items per page."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from typing import Any, Generic, TypeVar
+
+from .response import ZazuResponse
+
+MAX_PER_PAGE = 100
+
+T = TypeVar("T")
+
+
+class Page(Generic[T]):
+    """A single page of results plus a fetcher to load the next page on demand."""
+
+    def __init__(
+        self,
+        response: ZazuResponse,
+        fetcher: Callable[[str | None], "Page[T]"],
+    ) -> None:
+        self.response = response
+        self._fetcher = fetcher
+        body = response.body if isinstance(response.body, dict) else {}
+        self.data: list[T] = list(body.get("data") or [])
+        self.has_more: bool = bool(body.get("has_more"))
+        self.next_cursor: str | None = body.get("next_cursor")
+
+    def next(self) -> Page[T] | None:
+        """Fetch the next page, or None if there are no more results."""
+        if not self.has_more or not self.next_cursor:
+            return None
+        return self._fetcher(self.next_cursor)
+
+    def auto_paging_iter(self) -> Iterator[T]:
+        """Yield every item across all pages by chasing cursors."""
+        page: Page[T] | None = self
+        while page is not None:
+            yield from page.data
+            page = page.next()
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(self.data)
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __repr__(self) -> str:
+        return f"Page(items={len(self.data)}, has_more={self.has_more})"
+
+
+PageBody = dict[str, Any]
+PageFetcher = Callable[[str | None], Page[Any]]

zazu_sdk-0.2.1/src/zazu_sdk/resources/accounts.py

@@ -0,0 +1,64 @@
+"""Mirrors lib/zazu/resources/accounts.rb."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from ..page import MAX_PER_PAGE, Page
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class Accounts(ResourceBase):
+    def list(
+        self,
+        *,
+        status: str | None = None,
+        currency_code: str | None = None,
+        limit: int = MAX_PER_PAGE,
+        cursor: str | None = None,
+    ) -> Page[Any]:
+        return self.list_page(
+            "api/accounts",
+            {"status": status, "currency_code": currency_code},
+            limit=limit,
+            cursor=cursor,
+        )
+
+    def get(self, id: str) -> ZazuResponse:
+        return self.http_get(self.encode_path("api/accounts", id))
+
+    def list_transactions(
+        self,
+        account_id: str,
+        *,
+        operation: str | None = None,
+        posted_after: str | datetime | None = None,
+        posted_before: str | datetime | None = None,
+        limit: int = MAX_PER_PAGE,
+        cursor: str | None = None,
+    ) -> Page[Any]:
+        return self.list_page(
+            self.encode_path("api/accounts", account_id, "transactions"),
+            {
+                "operation": operation,
+                "posted_after": _serialize_time(posted_after),
+                "posted_before": _serialize_time(posted_before),
+            },
+            limit=limit,
+            cursor=cursor,
+        )
+
+    def get_transaction(self, account_id: str, transaction_id: str) -> ZazuResponse:
+        return self.http_get(
+            self.encode_path("api/accounts", account_id, "transactions", transaction_id)
+        )
+
+
+def _serialize_time(value: str | datetime | None) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return value
+    return value.isoformat()

zazu_sdk-0.2.1/src/zazu_sdk/resources/base.py

@@ -0,0 +1,89 @@
+"""Mirrors lib/zazu/resources/base.rb."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from urllib.parse import quote
+
+from ..errors import ZazuArgumentError
+from ..page import MAX_PER_PAGE, Page
+from ..response import ZazuResponse
+
+if TYPE_CHECKING:
+    from ..client import Zazu
+
+
+class ResourceBase:
+    def __init__(self, client: Zazu) -> None:
+        self._client = client
+
+    @staticmethod
+    def encode_path(base: str, *segments: str) -> str:
+        """Build a request path by joining a literal base path with dynamic
+        segments. The base is appended verbatim; each dynamic segment is
+        percent-encoded so an ID containing `/` or other special characters
+        cannot escape the intended path.
+
+            encode_path("api/accounts", "acc_xyz")
+              # => "api/accounts/acc_xyz"
+            encode_path("api/accounts", "acc 1", "transactions", "tx 1")
+              # => "api/accounts/acc%201/transactions/tx%201"
+        """
+        encoded = []
+        for seg in segments:
+            text = str(seg)
+            # An empty segment would silently turn `/things/:id` into
+            # `/things/`, which on most APIs redispatches to the list
+            # endpoint. Surface it loudly.
+            if not text:
+                raise ZazuArgumentError("path segment cannot be blank")
+            encoded.append(quote(text, safe=""))
+        return "/".join([base, *encoded])
+
+    def http_get(
+        self,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+    ) -> ZazuResponse:
+        return self._client.request("GET", path, params=params)
+
+    def http_post(
+        self,
+        path: str,
+        *,
+        body: Any = None,
+        params: dict[str, Any] | None = None,
+    ) -> ZazuResponse:
+        return self._client.request("POST", path, body=body, params=params)
+
+    def http_patch(
+        self,
+        path: str,
+        *,
+        body: Any = None,
+    ) -> ZazuResponse:
+        return self._client.request("PATCH", path, body=body)
+
+    def http_delete(self, path: str) -> ZazuResponse:
+        return self._client.request("DELETE", path)
+
+    def list_page(
+        self,
+        path: str,
+        params: dict[str, Any] | None = None,
+        *,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> Page[Any]:
+        merged: dict[str, Any] = dict(params or {})
+        if limit is not None:
+            merged["limit"] = min(limit, MAX_PER_PAGE)
+        if cursor is not None:
+            merged["cursor"] = cursor
+
+        def fetch(next_cursor: str | None) -> Page[Any]:
+            return self.list_page(path, params, limit=limit, cursor=next_cursor)
+
+        response = self.http_get(path, params=merged)
+        return Page(response, fetch)

zazu_sdk-0.2.1/src/zazu_sdk/resources/beneficiaries.py

@@ -0,0 +1,23 @@
+"""Mirrors lib/zazu/resources/beneficiaries.rb.
+
+Read-only directory of saved transfer recipients. Each beneficiary
+embeds its bank accounts; the one flagged ``default`` is used when a
+transfer names only the beneficiary_id. Beneficiaries are created and
+managed in the Zazu dashboard.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..page import MAX_PER_PAGE, Page
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class Beneficiaries(ResourceBase):
+    def list(self, *, limit: int = MAX_PER_PAGE, cursor: str | None = None) -> Page[Any]:
+        return self.list_page("api/beneficiaries", {}, limit=limit, cursor=cursor)
+
+    def get(self, id: str) -> ZazuResponse:
+        return self.http_get(self.encode_path("api/beneficiaries", id))

zazu_sdk-0.2.1/src/zazu_sdk/resources/checkout_sessions.py

@@ -0,0 +1,16 @@
+"""Mirrors lib/zazu/resources/checkout_sessions.rb."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class CheckoutSessions(ResourceBase):
+    def get(self, id: str) -> ZazuResponse:
+        return self.http_get(self.encode_path("api/checkout_sessions", id))
+
+    def create(self, **attributes: Any) -> ZazuResponse:
+        return self.http_post("api/checkout_sessions", body=attributes)

zazu_sdk-0.2.1/src/zazu_sdk/resources/customers.py

@@ -0,0 +1,32 @@
+"""Mirrors lib/zazu/resources/customers.rb."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..page import MAX_PER_PAGE, Page
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class Customers(ResourceBase):
+    def list(
+        self,
+        *,
+        q: str | None = None,
+        limit: int = MAX_PER_PAGE,
+        cursor: str | None = None,
+    ) -> Page[Any]:
+        return self.list_page("api/customers", {"q": q}, limit=limit, cursor=cursor)
+
+    def get(self, id: str) -> ZazuResponse:
+        return self.http_get(self.encode_path("api/customers", id))
+
+    def create(self, **attributes: Any) -> ZazuResponse:
+        return self.http_post("api/customers", body=attributes)
+
+    def update(self, id: str, **attributes: Any) -> ZazuResponse:
+        return self.http_patch(self.encode_path("api/customers", id), body=attributes)
+
+    def delete(self, id: str) -> ZazuResponse:
+        return self.http_delete(self.encode_path("api/customers", id))

zazu_sdk-0.2.1/src/zazu_sdk/resources/entity.py

@@ -0,0 +1,11 @@
+"""Mirrors lib/zazu/resources/entity.rb."""
+
+from __future__ import annotations
+
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class Entity(ResourceBase):
+    def get(self) -> ZazuResponse:
+        return self.http_get("api/entity")

zazu_sdk-0.2.1/src/zazu_sdk/resources/invoices.py

@@ -0,0 +1,56 @@
+"""Mirrors lib/zazu/resources/invoices.rb."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..page import MAX_PER_PAGE, Page
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class Invoices(ResourceBase):
+    def list(
+        self,
+        *,
+        status: str | None = None,
+        customer_id: str | None = None,
+        limit: int = MAX_PER_PAGE,
+        cursor: str | None = None,
+    ) -> Page[Any]:
+        return self.list_page(
+            "api/invoices",
+            {"status": status, "customer_id": customer_id},
+            limit=limit,
+            cursor=cursor,
+        )
+
+    def get(self, id: str) -> ZazuResponse:
+        return self.http_get(self.encode_path("api/invoices", id))
+
+    def create(self, **attributes: Any) -> ZazuResponse:
+        return self.http_post("api/invoices", body=attributes)
+
+    def update(self, id: str, **attributes: Any) -> ZazuResponse:
+        return self.http_patch(self.encode_path("api/invoices", id), body=attributes)
+
+    def send_invoice(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/invoices", id, "send"))
+
+    def mark_as_paid(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/invoices", id, "mark_as_paid"))
+
+    def cancel(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/invoices", id, "cancel"))
+
+    def credit_note(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/invoices", id, "credit_note"))
+
+    def delete(self, id: str) -> ZazuResponse:
+        return self.http_delete(self.encode_path("api/invoices", id))
+
+    def create_payment_link(self, invoice_id: str, *, account_id: str) -> ZazuResponse:
+        return self.http_post(
+            self.encode_path("api/invoices", invoice_id, "payment_link"),
+            body={"account_id": account_id},
+        )

zazu_sdk-0.2.1/src/zazu_sdk/resources/payment_links.py

@@ -0,0 +1,35 @@
+"""Mirrors lib/zazu/resources/payment_links.rb."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..page import MAX_PER_PAGE, Page
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class PaymentLinks(ResourceBase):
+    def list(
+        self,
+        *,
+        status: str | None = None,
+        link_type: str | None = None,
+        limit: int = MAX_PER_PAGE,
+        cursor: str | None = None,
+    ) -> Page[Any]:
+        return self.list_page(
+            "api/payment_links",
+            {"status": status, "link_type": link_type},
+            limit=limit,
+            cursor=cursor,
+        )
+
+    def get(self, id: str) -> ZazuResponse:
+        return self.http_get(self.encode_path("api/payment_links", id))
+
+    def create(self, **attributes: Any) -> ZazuResponse:
+        return self.http_post("api/payment_links", body=attributes)
+
+    def cancel(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/payment_links", id, "cancel"))

zazu_sdk-0.2.1/src/zazu_sdk/resources/transfer_drafts.py

@@ -0,0 +1,22 @@
+"""Mirrors lib/zazu/resources/transfer_drafts.rb.
+
+API-initiated transfers. Creating a draft routes it into the workspace's
+in-app approval flow — the API never executes a transfer itself. Poll
+``get`` (status: requested → processing → completed / failed) or
+subscribe to the ``transfer.executed`` webhook.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class TransferDrafts(ResourceBase):
+    def create(self, **attributes: Any) -> ZazuResponse:
+        return self.http_post("api/transfer_drafts", body=attributes)
+
+    def get(self, id: str) -> ZazuResponse:
+        return self.http_get(self.encode_path("api/transfer_drafts", id))

zazu_sdk-0.2.1/src/zazu_sdk/resources/webhook_endpoints.py

@@ -0,0 +1,53 @@
+"""Mirrors lib/zazu/resources/webhook_endpoints.rb."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from ..page import MAX_PER_PAGE, Page
+from ..response import ZazuResponse
+from .base import ResourceBase
+
+
+class WebhookEndpoints(ResourceBase):
+    def list(
+        self,
+        *,
+        limit: int = MAX_PER_PAGE,
+        cursor: str | None = None,
+    ) -> Page[Any]:
+        return self.list_page("api/webhook_endpoints", {}, limit=limit, cursor=cursor)
+
+    def get(self, id: str) -> ZazuResponse:
+        return self.http_get(self.encode_path("api/webhook_endpoints", id))
+
+    def create(
+        self,
+        *,
+        url: str,
+        events: Sequence[str],
+        description: str | None = None,
+    ) -> ZazuResponse:
+        body: dict[str, Any] = {"url": url, "events": list(events)}
+        if description is not None:
+            body["description"] = description
+        return self.http_post("api/webhook_endpoints", body=body)
+
+    def update(self, id: str, **attributes: Any) -> ZazuResponse:
+        return self.http_patch(self.encode_path("api/webhook_endpoints", id), body=attributes)
+
+    def delete(self, id: str) -> ZazuResponse:
+        return self.http_delete(self.encode_path("api/webhook_endpoints", id))
+
+    def test_endpoint(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/webhook_endpoints", id, "test"))
+
+    def regenerate_secret(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/webhook_endpoints", id, "regenerate_secret"))
+
+    def enable(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/webhook_endpoints", id, "enable"))
+
+    def disable(self, id: str) -> ZazuResponse:
+        return self.http_post(self.encode_path("api/webhook_endpoints", id, "disable"))

zazu_sdk-0.2.1/src/zazu_sdk/response.py

@@ -0,0 +1,26 @@
+"""Mirrors lib/zazu/response.rb."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+
+class ZazuResponse:
+    """Thin wrapper over httpx.Response — exposes status, headers, and parsed body."""
+
+    def __init__(self, raw: httpx.Response, body: Any) -> None:
+        self._raw = raw
+        self.status: int = raw.status_code
+        self.headers: httpx.Headers = raw.headers
+        self.body: Any = body
+
+    @property
+    def request_id(self) -> str | None:
+        value = self.headers.get("X-Request-Id")
+        return value if isinstance(value, str) else None
+
+    @property
+    def success(self) -> bool:
+        return 200 <= self.status < 300