memydev-base-sdk 0.1.0__py3-none-any.whl

memybase/_filter.py

@@ -0,0 +1,86 @@
+"""
+@fileoverview Fluent filter builder for MemyBase list queries.
+@module memybase._filter
+@description Supports the 14 operators (eq ne in nin gt gte lt lte contains startsWith istartsWith
+             endsWith exists between) matching the engine's filter contract (query-builder.ts
+             FILTER_OPERATORS). Produces the [{field,op,value}] JSON array the server expects.
+@created 2026-07-04
+"""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+__all__ = ["FilterBuilder", "OPERATORS", "serialize_filter"]
+
+OPERATORS: frozenset[str] = frozenset({
+    "eq", "ne", "in", "nin", "gt", "gte", "lt", "lte",
+    "contains", "startsWith", "istartsWith", "endsWith", "exists", "between",
+})
+
+
+class FilterBuilder:
+    """Fluent builder that accumulates [{field, op, value}] conditions."""
+
+    def __init__(self) -> None:
+        self._conditions: list[dict[str, Any]] = []
+
+    def where(self, field: str, op: str, value: Any = None) -> "FilterBuilder":
+        if op not in OPERATORS:
+            raise ValueError(f"Unknown operator '{op}'; valid: {sorted(OPERATORS)}")
+        # ALWAYS serialize `value` (mirror JS filter.ts) — including a null operand. The prior
+        # `if value is not None` guard dropped it, so an is-null filter (e.g. eq('archivedAt', None))
+        # emitted [{field,op}]; the server's assertScalar(undefined) then 400s. Sending value:null lets
+        # the query-builder compile {$eq: null} and match.
+        self._conditions.append({"field": field, "op": op, "value": value})
+        return self
+
+    def eq(self, field: str, value: Any) -> "FilterBuilder":
+        return self.where(field, "eq", value)
+
+    def ne(self, field: str, value: Any) -> "FilterBuilder":
+        return self.where(field, "ne", value)
+
+    def gt(self, field: str, value: Any) -> "FilterBuilder":
+        return self.where(field, "gt", value)
+
+    def gte(self, field: str, value: Any) -> "FilterBuilder":
+        return self.where(field, "gte", value)
+
+    def lt(self, field: str, value: Any) -> "FilterBuilder":
+        return self.where(field, "lt", value)
+
+    def lte(self, field: str, value: Any) -> "FilterBuilder":
+        return self.where(field, "lte", value)
+
+    def in_(self, field: str, values: list[Any]) -> "FilterBuilder":
+        return self.where(field, "in", values)
+
+    def nin(self, field: str, values: list[Any]) -> "FilterBuilder":
+        return self.where(field, "nin", values)
+
+    def contains(self, field: str, value: str) -> "FilterBuilder":
+        return self.where(field, "contains", value)
+
+    def starts_with(self, field: str, value: str) -> "FilterBuilder":
+        return self.where(field, "startsWith", value)
+
+    def istarts_with(self, field: str, value: str) -> "FilterBuilder":
+        """Case-INSENSITIVE anchored prefix (server `istartsWith` — {$regex:^…, $options:'i'})."""
+        return self.where(field, "istartsWith", value)
+
+    def ends_with(self, field: str, value: str) -> "FilterBuilder":
+        return self.where(field, "endsWith", value)
+
+    def exists(self, field: str, value: bool = True) -> "FilterBuilder":
+        return self.where(field, "exists", value)
+
+    def between(self, field: str, low: Any, high: Any) -> "FilterBuilder":
+        return self.where(field, "between", [low, high])
+
+    def build(self) -> list[dict[str, Any]]:
+        return list(self._conditions)
+
+
+def serialize_filter(conditions: list[dict[str, Any]]) -> str:
+    return json.dumps(conditions, separators=(",", ":"))

memybase/_graphql.py

@@ -0,0 +1,49 @@
+"""
+@fileoverview GraphQL read-only client for per-project generated schemas.
+@module memybase._graphql
+@description Sends GraphQL queries against the per-project /api/v1 graphql endpoint and reads the
+             generated schema.sdl artifact as text. Read-only (no mutations/subscriptions). API keys
+             work. Mirrors the JS SDK's GraphQLClient.
+@created 2026-07-04
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+from urllib.parse import quote
+
+from ._transport import Transport
+
+__all__ = ["GraphQLClient"]
+
+
+class GraphQLClient:
+    """Async GraphQL client for a specific project (optional database)."""
+
+    def __init__(
+        self,
+        transport: Transport,
+        *,
+        project: str,
+        database: Optional[str] = None,
+    ) -> None:
+        self._transport = transport
+        if database:
+            self._path = f"/api/v1/p/{quote(project, safe='')}/d/{quote(database, safe='')}/graphql"
+        else:
+            self._path = f"/api/v1/projects/{quote(project, safe='')}/graphql"
+
+    async def query(self, document: str, variables: Optional[dict[str, Any]] = None) -> Any:
+        """Execute a GraphQL query and return the response body ({data, errors?})."""
+        body: dict[str, Any] = {"query": document}
+        if variables:
+            body["variables"] = variables
+        return await self._transport.request("POST", self._path, json_body=body)
+
+    async def schema_sdl(self) -> str:
+        """GET {graphql_path}/schema.sdl as application/graphql text."""
+        return await self._transport.request(
+            "GET",
+            f"{self._path}/schema.sdl",
+            headers={"Accept": "application/graphql"},
+            text=True,
+        )

memybase/_helpers.py

@@ -0,0 +1,35 @@
+"""
+@fileoverview Conflict retry helper for expected-version race conditions.
+@module memybase._helpers
+@description MemyBase writes accept expected_version / If-Match preconditions; this helper retries on
+             ConflictError with linear backoff, mirroring the JS SDK's withConflictRetry().
+@created 2026-07-04
+"""
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Awaitable, Callable, TypeVar
+
+from memybase._errors import ConflictError  # absolute: shared module, no _sync twin (see gen_sync.py)
+
+__all__ = ["with_conflict_retry"]
+
+T = TypeVar("T")
+
+
+async def with_conflict_retry(
+    fn: Callable[[], Awaitable[T]],
+    *,
+    retries: int = 3,
+    delay: float = 0.2,
+) -> T:
+    """Retry fn() on ConflictError up to `retries` times with linear backoff."""
+    last_error: ConflictError | None = None
+    for attempt in range(retries + 1):
+        try:
+            return await fn()
+        except ConflictError as e:
+            last_error = e
+            if attempt < retries:
+                await asyncio.sleep(delay * (attempt + 1))
+    raise last_error  # type: ignore[misc]

memybase/_mapping.py

@@ -0,0 +1,55 @@
+"""
+@fileoverview Reserved-field guard and payload utilities.
+@module memybase._mapping
+@description Guards write payloads against the 15 non-writable engine-reserved system fields while
+             allowing the schema-reserved memyTtl exception. Strips
+             undefined/None keys from outbound payloads (null-omit rule). Mirrors the JS SDK's
+             mapping.ts and MemySwarm's mapping.py.
+@created 2026-07-04
+"""
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from ._errors import ReservedFieldError
+
+__all__ = [
+    "CUSTOMER_WRITABLE_RESERVED_FIELDS",
+    "RESERVED_FIELDS",
+    "SCHEMA_RESERVED_FIELDS",
+    "guard_reserved_fields",
+    "omit_none",
+]
+
+RESERVED_FIELDS: frozenset[str] = frozenset({
+    "_id",
+    "tenantId",
+    "projectId",
+    "entityId",
+    "schemaVersionId",
+    "createdAt",
+    "createdBy",
+    "updatedAt",
+    "updatedBy",
+    "deletedAt",
+    "deletedBy",
+    "deleteReason",
+    "version",
+    "_metadata",
+    "_system",
+})
+
+SCHEMA_RESERVED_FIELDS: frozenset[str] = RESERVED_FIELDS | {"memyTtl"}
+CUSTOMER_WRITABLE_RESERVED_FIELDS: frozenset[str] = frozenset({"memyTtl"})
+
+
+def guard_reserved_fields(body: Mapping[str, Any]) -> None:
+    """Raise ReservedFieldError if body contains any reserved key."""
+    violations = RESERVED_FIELDS.intersection(body.keys())
+    if violations:
+        raise ReservedFieldError(sorted(violations))
+
+
+def omit_none(body: Mapping[str, Any]) -> dict[str, Any]:
+    """Return a copy of body with None-valued keys removed (null-omit rule)."""
+    return {k: v for k, v in body.items() if v is not None}

memybase/_realtime.py

@@ -0,0 +1,295 @@
+"""
+@fileoverview SSE realtime subscription — ticket-based streaming with auto-reconnect.
+@module memybase._realtime
+@description Python port of the JS SDK's realtime.ts. Two-step flow: POST .../streams/tickets →
+             GET .../stream?ticket=. Parses SSE frames over an httpx streaming response, auto-
+             reconnects with bounded exponential backoff, re-mints the ticket on each attempt, tracks
+             Last-Event-ID for resume, and invokes on_resync when the server requests a re-snapshot.
+             ASYNC-ONLY: SSE is inherently async and the sync client (memybase.sync) targets scripts /
+             provisioning tooling with no event loop — realtime is deliberately not exposed there
+             (see sdk/py/tests/test_sync_parity.py's documented exclusion), mirroring the JS SDK,
+             which likewise ships realtime only on its single (async) client.
+@dependencies ._transport (open_sse), httpx (transitively)
+@relatedFiles ./_collection.py (Collection.subscribe), ./_client.py (MemyBase.stream),
+             ../../../js/src/realtime.ts (the reference implementation this mirrors 1:1)
+@created 2026-07-05
+"""
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+from urllib.parse import quote, urlsplit
+
+from ._transport import Transport
+
+__all__ = ["RealtimeClient", "StreamEvent", "SubscribeOptions", "Subscription"]
+
+# Backoff parity with realtime.ts: delay = min(1000 * 2^(n-1), 30_000) ms → seconds here.
+_RECONNECT_BASE = 1.0
+_RECONNECT_MAX = 30.0
+# Floor applied to EVERY reconnect delay — including a CLEAN stream end (EOF, no exception). A stream that
+# opens then immediately EOFs (LB idle-timeout, draining backend, crash-loop) would otherwise re-mint a
+# ticket + reconnect with zero delay, an RTT-bound hot loop hammering /streams/tickets. The floor bounds it.
+_RECONNECT_MIN = 0.5
+
+
+@dataclass(frozen=True)
+class StreamEvent:
+    """A realtime event — the faithful Python mirror of the JS StreamEvent discriminated union:
+
+      - event='ready'     data = {mode, entity, heartbeatMs}
+      - event='change'    data = {type, entity, id, op?, doc?}   (id = SSE id or None)
+      - event='heartbeat' data = <epoch-ms int>
+      - event='resync'    data = {reason}
+    """
+
+    event: str
+    data: Any
+    id: Optional[str] = None
+
+
+@dataclass
+class SubscribeOptions:
+    """Subscription options — 1:1 with the JS SubscribeOptions {entity, lastEventId, onResync, signal}.
+
+    signal maps the JS AbortSignal to the idiomatic Python cancellation token (asyncio.Event): set it
+    to abort the subscription from outside. The primary stop path is ``await subscription.close()``.
+    """
+
+    entity: Optional[str] = None
+    last_event_id: Optional[str] = None
+    on_resync: Optional[Callable[[str], None]] = None
+    signal: Optional[asyncio.Event] = None
+
+
+EventCallback = Callable[["StreamEvent"], None]
+
+
+class Subscription:
+    """Handle to a live subscription.
+
+    ``await subscription.close()`` cancels AND drains the background task (a deliberate divergence
+    from the JS ``close(): void`` so resources tear down cleanly). ``closed`` reflects state; ``wait()``
+    awaits the background task until it stops. Also an async context manager.
+    """
+
+    def __init__(self) -> None:
+        self._closed = False
+        self._task: Optional[asyncio.Task[None]] = None
+        self._watch_task: Optional[asyncio.Task[None]] = None
+        self._last_event_id: Optional[str] = None
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    async def close(self) -> None:
+        self._closed = True
+        for task in (self._task, self._watch_task):
+            if task is not None:
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+
+    async def wait(self) -> None:
+        """Await the background reconnect task until the subscription stops (closed / terminal)."""
+        if self._task is not None:
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._task
+
+    async def __aenter__(self) -> "Subscription":
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.close()
+
+
+def _resync_reason(data: Any) -> str:
+    """Extract a resync reason robustly, mirroring realtime.ts `parsed.reason ?? 'unknown'`. A non-object
+    payload (a bare scalar) or a null/missing reason both collapse to 'unknown' — never an AttributeError
+    that would drop the whole event (the prior `data.get(...)` raised on a scalar payload)."""
+    reason = data.get("reason") if isinstance(data, dict) else None
+    return reason if isinstance(reason, str) else "unknown"
+
+
+def _stream_path(stream: str) -> str:
+    """Mirror realtime.ts: an absolute '/...' path is used verbatim; a full URL → path+query only."""
+    if stream.startswith("/"):
+        return stream
+    parts = urlsplit(stream)
+    return parts.path + (f"?{parts.query}" if parts.query else "")
+
+
+class RealtimeClient:
+    """Async SSE realtime client. Obtain subscriptions via ``MemyBase.stream`` or
+    ``Collection.subscribe``; direct use is also supported."""
+
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    async def subscribe(
+        self,
+        project: str,
+        database: Optional[str],
+        on_event: EventCallback,
+        opts: Optional[SubscribeOptions] = None,
+    ) -> Subscription:
+        """Start a subscription; returns immediately with a live Subscription (the reconnect loop runs
+        in a background task, mirroring realtime.ts firing ``connect()`` without awaiting)."""
+        opts = opts or SubscribeOptions()
+
+        if database:
+            ticket_path = (
+                f"/api/v1/p/{quote(project, safe='')}/d/{quote(database, safe='')}/streams/tickets"
+            )
+        else:
+            ticket_path = f"/api/v1/projects/{quote(project, safe='')}/streams/tickets"
+
+        sub = Subscription()
+        sub._last_event_id = opts.last_event_id
+        sub._task = asyncio.create_task(self._run(ticket_path, on_event, opts, sub))
+
+        if opts.signal is not None:
+            async def _watch() -> None:
+                with contextlib.suppress(asyncio.CancelledError):
+                    await opts.signal.wait()  # type: ignore[union-attr]
+                    await sub.close()
+
+            sub._watch_task = asyncio.create_task(_watch())
+
+        return sub
+
+    async def _run(
+        self,
+        ticket_path: str,
+        on_event: EventCallback,
+        opts: SubscribeOptions,
+        sub: Subscription,
+    ) -> None:
+        # Reconnect loop mirroring realtime.ts connect(): re-mint the ticket every iteration, reset the
+        # backoff after the stream opens, preserve Last-Event-ID across reconnects. Reconnects on ANY
+        # error (including 401/403/404) exactly like the JS SDK — see the module note.
+        reconnect_attempt = 0
+        while not sub._closed:
+            try:
+                # Yield each iteration so a tight clean-reconnect loop (a server that closes the stream
+                # immediately) can never starve concurrent tasks, and so cancellation from close() is
+                # always observed promptly. A no-op on the healthy path — a live SSE stream blocks in
+                # aiter_lines, so this only fires between (re)connections.
+                await asyncio.sleep(0)
+                ticket_body: dict[str, Any] = {}
+                if opts.entity:
+                    ticket_body["entity"] = opts.entity
+                ticket = await self._transport.request(
+                    "POST", ticket_path, json_body=ticket_body or None
+                )
+                stream_path = _stream_path(ticket["stream"])
+                async with self._transport.open_sse(
+                    stream_path, last_event_id=sub._last_event_id
+                ) as resp:
+                    reconnect_attempt = 0
+                    await self._consume(resp, on_event, opts, sub)
+                # Reached here ⇒ the stream ended CLEANLY (EOF, no exception). This is still a reconnect,
+                # so it gets a FLOOR backoff (rank 34) — otherwise a fast-closing stream re-mints with no
+                # delay. Route it through the same throttle as the error path.
+                if sub._closed:
+                    return
+                reconnect_attempt += 1
+                await self._backoff_sleep(reconnect_attempt)
+            except asyncio.CancelledError:
+                return
+            except Exception:
+                if sub._closed:
+                    return
+                reconnect_attempt += 1
+                await self._backoff_sleep(reconnect_attempt)
+
+    async def _backoff_sleep(self, attempt: int) -> None:
+        """Sleep the reconnect backoff for ``attempt``, never below ``_RECONNECT_MIN`` (so even a clean
+        fast-close is throttled). Returns quietly on cancellation from close()."""
+        delay = min(_RECONNECT_BASE * (2 ** (attempt - 1)), _RECONNECT_MAX)
+        delay = max(delay, _RECONNECT_MIN)
+        try:
+            await asyncio.sleep(delay)
+        except asyncio.CancelledError:
+            return
+
+    async def _consume(
+        self,
+        resp: Any,
+        on_event: EventCallback,
+        opts: SubscribeOptions,
+        sub: Subscription,
+    ) -> None:
+        # SSE frame parser mirroring consumeStream/dispatchEvent EXACTLY. httpx aiter_lines() yields
+        # each line (newline stripped) and an empty string '' for a blank-line frame separator.
+        current_event = ""
+        current_data = ""
+        current_id = ""
+        async for line in resp.aiter_lines():
+            if sub._closed:
+                return
+            if line == "":
+                if current_data:
+                    if current_id:
+                        sub._last_event_id = current_id
+                    self._dispatch(current_event, current_data, current_id, on_event, opts)
+                current_event = ""
+                current_data = ""
+                current_id = ""
+                continue
+            if line.startswith(":"):  # comment / keep-alive
+                continue
+            colon = line.find(":")
+            if colon == -1:
+                field_name, value = line, ""
+            else:
+                field_name = line[:colon]
+                value = line[colon + 1 :]
+                if value.startswith(" "):  # strip exactly one leading space
+                    value = value[1:]
+            if field_name == "event":
+                current_event = value
+            elif field_name == "data":
+                current_data = f"{current_data}\n{value}" if current_data else value
+            elif field_name == "id":
+                current_id = value
+
+    def _dispatch(
+        self,
+        event: str,
+        data: str,
+        id_: str,
+        on_event: EventCallback,
+        opts: SubscribeOptions,
+    ) -> None:
+        # 1. PARSE — a malformed SSE payload skips the frame (mirrors realtime.ts). Kept narrow so a bad
+        #    payload can never be confused with a consumer-callback error handled separately below.
+        try:
+            if event == "ready":
+                evt = StreamEvent("ready", json.loads(data))
+            elif event == "change":
+                evt = StreamEvent("change", json.loads(data), id=id_ or None)
+            elif event == "heartbeat":
+                evt = StreamEvent("heartbeat", int(data))
+            elif event == "resync":
+                evt = StreamEvent("resync", json.loads(data))
+            else:
+                return
+        except (ValueError, TypeError):
+            return  # malformed SSE data — skip the frame
+
+        # 2. DISPATCH — a consumer callback (on_event / on_resync) raising must NEVER propagate into _run's
+        #    reconnect `except Exception`: otherwise a buggy callback (e.g. a KeyError on a missing field)
+        #    turns into an unbounded ticket-mint + reconnect storm against /streams/tickets. Swallow here,
+        #    exactly like realtime.ts's dispatchEvent catch — callback failures are isolated from transport
+        #    failures, and the stream keeps flowing.
+        try:
+            if evt.event == "resync" and opts.on_resync:
+                opts.on_resync(_resync_reason(evt.data))
+            on_event(evt)
+        except Exception:
+            pass

memybase/_self.py

@@ -0,0 +1,137 @@
+"""
+@fileoverview Customer self-service operations on /api/self/*.
+@module memybase._self
+@description Mirrors the /api/self router 1:1: profile, openapi, projects CRUD + archive/restore,
+             databases CRUD, schema versions/activate, api-keys,
+             settings, plan, usage. All methods require tenant-level auth.
+@created 2026-07-04
+"""
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+# Absolute import of the shared/pure module (same pattern as _collection.py / _transport.py): unasync
+# generates memybase/_sync/_self.py, whose relative `from ._types` would resolve to a nonexistent
+# memybase/_sync/_types.py — the absolute path makes both the async module and its sync twin bind the
+# SAME single _types module.
+from memybase._types import SchemaActivationJobSummary
+
+from ._transport import Transport
+
+__all__ = ["SelfService"]
+
+_e = lambda s: quote(str(s), safe="")  # noqa: E731
+
+
+class SelfService:
+    """Async handle for authenticated /api/self/* customer endpoints."""
+
+    def __init__(self, transport: Transport) -> None:
+        self._t = transport
+
+    # ── Profile ──────────────────────────────────────────────────────────────
+    async def profile(self) -> Any:
+        return await self._t.request("GET", "/api/self/profile")
+
+    async def openapi(self) -> Any:
+        return await self._t.request("GET", "/api/self/openapi.json")
+
+    # ── Projects ─────────────────────────────────────────────────────────────
+    async def list_projects(self) -> Any:
+        return await self._t.request("GET", "/api/self/projects")
+
+    async def create_project(self, body: dict[str, Any]) -> Any:
+        return await self._t.request("POST", "/api/self/projects", json_body=body)
+
+    async def get_project(self, ref: str) -> Any:
+        return await self._t.request("GET", f"/api/self/projects/{_e(ref)}")
+
+    async def update_project(self, ref: str, body: dict[str, Any]) -> Any:
+        return await self._t.request("PATCH", f"/api/self/projects/{_e(ref)}", json_body=body)
+
+    async def archive_project(self, ref: str) -> None:
+        await self._t.request("POST", f"/api/self/projects/{_e(ref)}/archive")
+
+    async def restore_project(self, ref: str) -> None:
+        await self._t.request("POST", f"/api/self/projects/{_e(ref)}/restore")
+
+    async def delete_project(self, ref: str) -> None:
+        await self._t.request("DELETE", f"/api/self/projects/{_e(ref)}")
+
+    # ── Databases ────────────────────────────────────────────────────────────
+    async def list_databases(self, project_ref: str) -> Any:
+        return await self._t.request("GET", f"/api/self/projects/{_e(project_ref)}/databases")
+
+    async def create_database(self, project_ref: str, body: dict[str, Any]) -> Any:
+        return await self._t.request("POST", f"/api/self/projects/{_e(project_ref)}/databases", json_body=body)
+
+    async def delete_database(self, project_ref: str, db: str) -> None:
+        await self._t.request("DELETE", f"/api/self/projects/{_e(project_ref)}/databases/{_e(db)}")
+
+    async def archive_database(self, project_ref: str, db: str) -> None:
+        await self._t.request("POST", f"/api/self/projects/{_e(project_ref)}/databases/{_e(db)}/archive")
+
+    async def restore_database(self, project_ref: str, db: str) -> None:
+        await self._t.request("POST", f"/api/self/projects/{_e(project_ref)}/databases/{_e(db)}/restore")
+
+    # ── Schema ───────────────────────────────────────────────────────────────
+    async def list_schema_versions(self, project_ref: str, db: str | None = None) -> Any:
+        base = f"/api/self/projects/{_e(project_ref)}"
+        path = f"{base}/databases/{_e(db)}/schema/versions" if db else f"{base}/schema/versions"
+        return await self._t.request("GET", path)
+
+    async def activate_schema(self, project_ref: str, draft: dict[str, Any], db: str | None = None) -> Any:
+        base = f"/api/self/projects/{_e(project_ref)}"
+        path = f"{base}/databases/{_e(db)}/schema/activate" if db else f"{base}/schema/activate"
+        return await self._t.request("POST", path, json_body=draft)
+
+    async def activate_schema_spec(self, project_ref: str, spec: dict[str, Any], db: str | None = None) -> Any:
+        base = f"/api/self/projects/{_e(project_ref)}"
+        path = f"{base}/databases/{_e(db)}/schema/design" if db else f"{base}/schema/design"
+        return await self._t.request("POST", path, json_body=spec)
+
+    async def get_schema_activation(
+        self, project_ref: str, job_id: str, db: str | None = None
+    ) -> SchemaActivationJobSummary:
+        base = f"/api/self/projects/{_e(project_ref)}"
+        path = f"{base}/databases/{_e(db)}/schema/activations/{_e(job_id)}" if db else f"{base}/schema/activations/{_e(job_id)}"
+        return await self._t.request("GET", path)
+
+    async def rollback_schema_activation(
+        self, project_ref: str, job_id: str, db: str | None = None
+    ) -> SchemaActivationJobSummary:
+        base = f"/api/self/projects/{_e(project_ref)}"
+        path = f"{base}/databases/{_e(db)}/schema/activations/{_e(job_id)}/rollback" if db else f"{base}/schema/activations/{_e(job_id)}/rollback"
+        return await self._t.request("POST", path)
+
+    # ── Settings ─────────────────────────────────────────────────────────────
+    async def get_settings(self, scope_type: str | None = None, scope_id: str | None = None) -> Any:
+        if scope_type and scope_id:
+            return await self._t.request("GET", f"/api/self/settings/{_e(scope_type)}/{_e(scope_id)}")
+        return await self._t.request("GET", "/api/self/settings")
+
+    async def update_settings(self, values: dict[str, Any], scope_type: str | None = None, scope_id: str | None = None) -> Any:
+        if scope_type and scope_id:
+            return await self._t.request("PUT", f"/api/self/settings/{_e(scope_type)}/{_e(scope_id)}", json_body=values)
+        return await self._t.request("PUT", "/api/self/settings", json_body=values)
+
+    # ── API Keys ─────────────────────────────────────────────────────────────
+    async def list_api_keys(self) -> Any:
+        return await self._t.request("GET", "/api/self/api-keys")
+
+    async def create_api_key(self, body: dict[str, Any]) -> Any:
+        return await self._t.request("POST", "/api/self/api-keys", json_body=body)
+
+    async def revoke_api_key(self, key_id: str) -> None:
+        await self._t.request("DELETE", f"/api/self/api-keys/{_e(key_id)}")
+
+    async def purge_api_key(self, key_id: str) -> None:
+        await self._t.request("DELETE", f"/api/self/api-keys/{_e(key_id)}/purge")
+
+    # ── Plan & Usage ─────────────────────────────────────────────────────────
+    async def get_plan(self) -> Any:
+        return await self._t.request("GET", "/api/self/plan")
+
+    async def get_usage(self) -> Any:
+        return await self._t.request("GET", "/api/self/usage")

memybase/_sync/__init__.py

@@ -0,0 +1,3 @@
+# GENERATED by scripts/gen_sync.py from memybase/__init__.py — DO NOT EDIT.
+# Regenerate: python sdk/py/scripts/gen_sync.py   (CI gate: gen_sync.py --check).
+"""Generated synchronous twins of the memybase async modules — see scripts/gen_sync.py."""