memorysync 1.2.0__tar.gz → 1.3.0__tar.gz

{memorysync-1.2.0 → memorysync-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorysync
-Version: 1.2.0
+Version: 1.3.0
 Summary: Official Python client for the MemorySync API.
 Project-URL: Homepage, https://memorysync.io
 Project-URL: Documentation, https://docs.memorysync.io

{memorysync-1.2.0 → memorysync-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memorysync"
-version = "1.2.0"
+version = "1.3.0"
 description = "Official Python client for the MemorySync API."
 readme = "README.md"
 license = { text = "MIT" }

memorysync-1.3.0/src/memorysync/_version.py

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

{memorysync-1.2.0 → memorysync-1.3.0}/src/memorysync/client.py

@@ -260,6 +260,29 @@ class MemorySyncClient:
         self._project_id = project_id
         self._end_user_id = end_user_id
         self._http = httpx.Client(timeout=timeout, transport=transport)
+        self._attach_namespaces()
+
+    def _attach_namespaces(self) -> None:
+        """Wire the connector namespaces onto this client.
+
+        The namespace classes are shared with the async client — they only ever
+        hand a path to ``self._request``, so what comes back is a dict here and a
+        coroutine there. See ``connections.py`` for why that is one set of classes
+        rather than two.
+        """
+        from .connections import (
+            ConnectionsNamespace,
+            IntegrationsNamespace,
+            ObjectsNamespace,
+            ProvidersNamespace,
+            SyncJobsNamespace,
+        )
+
+        self.connections = ConnectionsNamespace(self._request)
+        self.objects = ObjectsNamespace(self._request)
+        self.providers = ProvidersNamespace(self._request)
+        self.sync_jobs = SyncJobsNamespace(self._request)
+        self.integrations = IntegrationsNamespace(self._request)
 
     def __enter__(self) -> "MemorySyncClient":
         return self
@@ -913,6 +936,29 @@ class AsyncMemorySyncClient:
         self._project_id = project_id
         self._end_user_id = end_user_id
         self._http = httpx.AsyncClient(timeout=timeout, transport=transport)
+        self._attach_namespaces()
+
+    def _attach_namespaces(self) -> None:
+        """Wire the connector namespaces onto this client.
+
+        Same classes as the sync client. Because they simply return whatever
+        ``self._request`` returns, and this client's ``_request`` is a coroutine
+        function, every namespace method here is awaitable:
+        ``await client.connections.list()``.
+        """
+        from .connections import (
+            ConnectionsNamespace,
+            IntegrationsNamespace,
+            ObjectsNamespace,
+            ProvidersNamespace,
+            SyncJobsNamespace,
+        )
+
+        self.connections = ConnectionsNamespace(self._request)
+        self.objects = ObjectsNamespace(self._request)
+        self.providers = ProvidersNamespace(self._request)
+        self.sync_jobs = SyncJobsNamespace(self._request)
+        self.integrations = IntegrationsNamespace(self._request)
 
     async def __aenter__(self) -> "AsyncMemorySyncClient":
         return self

memorysync-1.3.0/src/memorysync/connections.py

@@ -0,0 +1,680 @@
+"""Connector namespaces — ``client.connections``, ``client.objects`` and friends.
+
+Covers the connector API: creating and managing connections to Slack, Google
+Drive, S3 and Granola, driving syncs, and inspecting the objects a sync produced.
+Shaped after ``client.connections.*`` in comparable SDKs so the layout is
+familiar.
+
+One set of classes serves both clients
+--------------------------------------
+Every method here is a thin pass-through: build a path, hand it to the client's
+``_request``, return what comes back. Nothing post-processes the response. That
+means the *same* class works for the sync and async clients — ``MemorySyncClient``
+hands over a ``_request`` that returns a dict, ``AsyncMemorySyncClient`` hands over
+one that returns a coroutine.
+
+So on the sync client::
+
+    conns = client.connections.list()
+
+and on the async client::
+
+    conns = await client.connections.list()
+
+The alternative was 22 near-identical classes differing only by ``await``, which
+would double the surface area to review and to keep in step. The cost is that
+return types are annotated ``Any`` rather than a precise dict-or-awaitable union,
+and that is called out on every method group rather than left to be discovered.
+
+Why these return raw payloads
+-----------------------------
+Connector responses are large, provider-shaped and still moving — a Slack channel
+listing looks nothing like an S3 prefix listing, and both carry provider fields
+that change when the provider changes. Freezing them into dataclasses would mean
+an SDK release every time a provider adds a field, and callers unable to see the
+new field until then. Typed models are reserved for the small, stable, first-party
+shapes (memories, history, feedback, ontology).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional, Sequence
+from urllib.parse import quote
+
+_V2 = "/api/v2/integrations"
+_V1 = "/api/v1/integrations"
+
+# A bound ``_request`` from either client.
+RequestFn = Callable[..., Any]
+
+
+def _seg(value: Any) -> str:
+    """Percent-encode one path segment.
+
+    Connection, object and channel ids come from providers, not from us. A Slack
+    channel id is tame but a Drive resource id or an S3 prefix is not, and an
+    unencoded ``/`` in one of them would silently change which route is called.
+    """
+    return quote(str(value), safe="")
+
+
+class _Namespace:
+    """Holds the bound request function. Subclasses add methods."""
+
+    __slots__ = ("_request",)
+
+    def __init__(self, request: RequestFn) -> None:
+        self._request = request
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Provider-specific namespaces
+#
+# Reached as ``client.connections.slack``, ``.gdrive``, ``.s3``, ``.granola``.
+# Each takes the connection id first because a provider setting only means
+# anything relative to one connection.
+# ─────────────────────────────────────────────────────────────────────
+
+
+class SlackNamespace(_Namespace):
+    """Slack connection settings. Awaitable on the async client."""
+
+    def available_channels(self, connection_id: str, **params: Any) -> Any:
+        """Channels the app can see and could be added.
+
+        Private channels appear only where the deployment allows them *and* a
+        human has invited the app, so this never widens what someone already
+        granted.
+        """
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/slack/available-channels",
+            params=params or None,
+        )
+
+    def channels(self, connection_id: str) -> Any:
+        """Channels currently selected for syncing."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/slack/channels"
+        )
+
+    def add_channels(self, connection_id: str, channel_ids: Sequence[str]) -> Any:
+        """Select channels for syncing."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/slack/channels",
+            json={"channel_ids": list(channel_ids)},
+        )
+
+    def remove_channel(self, connection_id: str, channel_id: str) -> Any:
+        """Stop syncing one channel."""
+        return self._request(
+            "DELETE",
+            f"{_V2}/connections/{_seg(connection_id)}/slack/channels/{_seg(channel_id)}",
+        )
+
+    def exclusion_policy(self, connection_id: str) -> Any:
+        """Channels this connection will never sync.
+
+        The deployment-wide floor cannot be removed here; a tenant may only add
+        to it.
+        """
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/slack/exclusion-policy"
+        )
+
+    def set_exclusion_policy(self, connection_id: str, **policy: Any) -> Any:
+        """Replace this connection's additions to the exclusion policy."""
+        return self._request(
+            "PUT", f"{_V2}/connections/{_seg(connection_id)}/slack/exclusion-policy",
+            json=policy,
+        )
+
+    def identities(self, connection_id: str) -> Any:
+        """Slack users seen on this connection and who they map to."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/slack/identities"
+        )
+
+    def link_identity(self, connection_id: str, **body: Any) -> Any:
+        """Map a Slack user to a MemorySync end user."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/slack/identities/link",
+            json=body,
+        )
+
+    def sync_identities(self, connection_id: str) -> Any:
+        """Re-read the Slack member list and refresh the identity table."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/slack/identities/sync"
+        )
+
+
+class GoogleDriveNamespace(_Namespace):
+    """Google Drive connection settings. Awaitable on the async client."""
+
+    def picker_config(self, connection_id: str) -> Any:
+        """Config for rendering Google's own file picker in your UI."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/gdrive/picker-config"
+        )
+
+    def resources(self, connection_id: str, **params: Any) -> Any:
+        """Files and folders selected for syncing."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/gdrive/resources",
+            params=params or None,
+        )
+
+    def add_resources(self, connection_id: str, **body: Any) -> Any:
+        """Select files or folders for syncing."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/gdrive/resources",
+            json=body,
+        )
+
+    def remove_resource(self, connection_id: str, resource_id: str) -> Any:
+        """Stop syncing one file or folder."""
+        return self._request(
+            "DELETE",
+            f"{_V2}/connections/{_seg(connection_id)}/gdrive/resources/{_seg(resource_id)}",
+        )
+
+
+class S3Namespace(_Namespace):
+    """S3 connection settings. Awaitable on the async client."""
+
+    def available_prefixes(self, connection_id: str, **params: Any) -> Any:
+        """Prefixes visible in the bucket that could be added."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/s3/available-prefixes",
+            params=params or None,
+        )
+
+    def prefixes(self, connection_id: str) -> Any:
+        """Prefixes currently selected for syncing."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/s3/prefixes"
+        )
+
+    def add_prefixes(self, connection_id: str, prefixes: Sequence[str]) -> Any:
+        """Select prefixes for syncing."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/s3/prefixes",
+            json={"prefixes": list(prefixes)},
+        )
+
+    def remove_prefixes(self, connection_id: str, prefixes: Sequence[str]) -> Any:
+        """Stop syncing the given prefixes."""
+        return self._request(
+            "DELETE", f"{_V2}/connections/{_seg(connection_id)}/s3/prefixes",
+            json={"prefixes": list(prefixes)},
+        )
+
+    def exclusion_policy(self, connection_id: str) -> Any:
+        """Keys and patterns this connection will never sync."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/s3/exclusion-policy"
+        )
+
+    def set_exclusion_policy(self, connection_id: str, **policy: Any) -> Any:
+        """Replace this connection's additions to the exclusion policy."""
+        return self._request(
+            "PUT", f"{_V2}/connections/{_seg(connection_id)}/s3/exclusion-policy",
+            json=policy,
+        )
+
+    def settings(self, connection_id: str) -> Any:
+        """Effective S3 settings, including the per-object size ceiling."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/s3/settings"
+        )
+
+
+class GranolaNamespace(_Namespace):
+    """Granola connection settings. Awaitable on the async client."""
+
+    def available_folders(self, connection_id: str, **params: Any) -> Any:
+        """Folders that could be added."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/granola/available-folders",
+            params=params or None,
+        )
+
+    def folders(self, connection_id: str) -> Any:
+        """Folders currently selected for syncing."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/granola/folders"
+        )
+
+    def add_folders(self, connection_id: str, **body: Any) -> Any:
+        """Select folders for syncing."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/granola/folders",
+            json=body,
+        )
+
+    def remove_folder(self, connection_id: str, folder_id: str) -> Any:
+        """Stop syncing one folder."""
+        return self._request(
+            "DELETE",
+            f"{_V2}/connections/{_seg(connection_id)}/granola/folders/{_seg(folder_id)}",
+        )
+
+    def exclusion_policy(self, connection_id: str) -> Any:
+        """Folders and meetings this connection will never sync."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/granola/exclusion-policy"
+        )
+
+    def set_exclusion_policy(self, connection_id: str, **policy: Any) -> Any:
+        """Replace this connection's additions to the exclusion policy."""
+        return self._request(
+            "PUT", f"{_V2}/connections/{_seg(connection_id)}/granola/exclusion-policy",
+            json=policy,
+        )
+
+    def identities(self, connection_id: str) -> Any:
+        """Meeting participants seen on this connection and who they map to."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/granola/identities"
+        )
+
+    def link_identity(self, connection_id: str, **body: Any) -> Any:
+        """Map a participant to a MemorySync end user."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/granola/identities/link",
+            json=body,
+        )
+
+    def relink_identity(self, connection_id: str, **body: Any) -> Any:
+        """Move an existing mapping to a different end user."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/granola/identities/relink",
+            json=body,
+        )
+
+    def settings(self, connection_id: str) -> Any:
+        """Effective Granola settings for this connection."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/granola/settings"
+        )
+
+    def set_settings(self, connection_id: str, **settings: Any) -> Any:
+        """Update Granola settings for this connection."""
+        return self._request(
+            "PUT", f"{_V2}/connections/{_seg(connection_id)}/granola/settings",
+            json=settings,
+        )
+
+
+# ─────────────────────────────────────────────────────────────────────
+# OAuth handshake
+# ─────────────────────────────────────────────────────────────────────
+
+
+class ConnectionOAuthNamespace(_Namespace):
+    """Starting an OAuth connection. Awaitable on the async client."""
+
+    def initiate(self, provider: str, **body: Any) -> Any:
+        """Begin an OAuth connection and get the URL to send the user to.
+
+        The user completes consent in a browser; the provider then calls the
+        platform back. Poll :meth:`status` to find out how it went — the callback
+        does not come to your backend.
+        """
+        payload = {"provider": provider}
+        payload.update(body)
+        return self._request("POST", f"{_V2}/oauth/initiate", json=payload)
+
+    def status(self, **params: Any) -> Any:
+        """Where an in-flight OAuth connection got to."""
+        return self._request("GET", f"{_V2}/oauth/status", params=params or None)
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Connections
+# ─────────────────────────────────────────────────────────────────────
+
+
+class ConnectionsNamespace(_Namespace):
+    """Connections to external sources. Awaitable on the async client.
+
+    Provider-specific settings live in sub-namespaces: ``connections.slack``,
+    ``connections.gdrive``, ``connections.s3``, ``connections.granola``.
+    """
+
+    def __init__(self, request: RequestFn) -> None:
+        super().__init__(request)
+        self.slack = SlackNamespace(request)
+        self.gdrive = GoogleDriveNamespace(request)
+        self.s3 = S3Namespace(request)
+        self.granola = GranolaNamespace(request)
+        self.oauth = ConnectionOAuthNamespace(request)
+
+    # ── lifecycle ────────────────────────────────────────────────────
+
+    def list(self, **params: Any) -> Any:
+        """Every connection in this organization."""
+        return self._request("GET", f"{_V2}/connections", params=params or None)
+
+    def get(self, connection_id: str) -> Any:
+        """One connection, including its status and last sync."""
+        return self._request("GET", f"{_V2}/connections/{_seg(connection_id)}")
+
+    def create_with_api_key(self, provider: str, api_key: str, **body: Any) -> Any:
+        """Connect a provider that authenticates with an API key or bot token."""
+        payload: Dict[str, Any] = {"provider": provider, "api_key": api_key}
+        payload.update(body)
+        return self._request("POST", f"{_V2}/connections/api-key", json=payload)
+
+    def create_with_credentials(self, provider: str, credentials: Dict[str, Any], **body: Any) -> Any:
+        """Connect a provider that needs a credential bundle, such as S3 keys."""
+        payload: Dict[str, Any] = {"provider": provider, "credentials": credentials}
+        payload.update(body)
+        return self._request("POST", f"{_V2}/connections/credentials", json=payload)
+
+    def update(self, connection_id: str, **body: Any) -> Any:
+        """Change a connection's name, schedule or settings."""
+        return self._request(
+            "PATCH", f"{_V2}/connections/{_seg(connection_id)}", json=body
+        )
+
+    def delete(self, connection_id: str) -> Any:
+        """Remove a connection.
+
+        This stops future syncing. Memories already extracted are not removed —
+        use :meth:`purge` for that, so disconnecting never silently deletes
+        knowledge someone still depends on.
+        """
+        return self._request("DELETE", f"{_V2}/connections/{_seg(connection_id)}")
+
+    def reconnect(self, connection_id: str, **body: Any) -> Any:
+        """Re-authorise a connection whose credentials expired or were revoked."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/reconnect", json=body or None
+        )
+
+    def purge(self, connection_id: str, **body: Any) -> Any:
+        """Delete the memories this connection produced.
+
+        Separate from :meth:`delete` on purpose: removing a connection and
+        removing what it taught you are different decisions.
+        """
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/purge", json=body or None
+        )
+
+    # ── syncing ──────────────────────────────────────────────────────
+
+    def sync_status(self, connection_id: str) -> Any:
+        """Current and recent sync state for a connection."""
+        return self._request("GET", f"{_V2}/connections/{_seg(connection_id)}/sync")
+
+    def trigger_sync(self, connection_id: str, **body: Any) -> Any:
+        """Start a sync now instead of waiting for the schedule."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/sync", json=body or None
+        )
+
+    # ── objects produced by a connection ─────────────────────────────
+
+    def objects(self, connection_id: str, **params: Any) -> Any:
+        """Objects a connection has ingested — files, messages, meetings."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/objects",
+            params=params or None,
+        )
+
+    def objects_v2(self, connection_id: str, **params: Any) -> Any:
+        """Object listing with richer filtering and paging than :meth:`objects`."""
+        return self._request(
+            "GET", f"{_V2}/connections/{_seg(connection_id)}/objects/v2",
+            params=params or None,
+        )
+
+    def bulk_object_action(self, connection_id: str, **body: Any) -> Any:
+        """Apply one action to many objects — pause, resume, re-extract."""
+        return self._request(
+            "POST", f"{_V2}/connections/{_seg(connection_id)}/objects/bulk", json=body
+        )
+
+    # ── organization-wide ────────────────────────────────────────────
+
+    def stats(self, **params: Any) -> Any:
+        """Connector totals: connections, objects synced, memories produced."""
+        return self._request("GET", f"{_V2}/stats", params=params or None)
+
+    def audit_logs(self, **params: Any) -> Any:
+        """Audit trail of connector activity."""
+        return self._request("GET", f"{_V2}/audit-logs", params=params or None)
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Objects
+# ─────────────────────────────────────────────────────────────────────
+
+
+class ObjectsNamespace(_Namespace):
+    """A single synced object. Awaitable on the async client.
+
+    An "object" is one thing a connector ingested: a Drive file, a Slack message
+    batch, an S3 key, a meeting transcript.
+    """
+
+    def get(self, object_id: str) -> Any:
+        """Metadata and sync state for one object."""
+        return self._request("GET", f"{_V2}/objects/{_seg(object_id)}")
+
+    def analysis(self, object_id: str) -> Any:
+        """What extraction made of this object."""
+        return self._request("GET", f"{_V2}/objects/{_seg(object_id)}/analysis")
+
+    def audit(self, object_id: str, **params: Any) -> Any:
+        """Every action taken on this object."""
+        return self._request(
+            "GET", f"{_V2}/objects/{_seg(object_id)}/audit", params=params or None
+        )
+
+    def history(self, object_id: str, **params: Any) -> Any:
+        """Versions of this object seen across syncs."""
+        return self._request(
+            "GET", f"{_V2}/objects/{_seg(object_id)}/history", params=params or None
+        )
+
+    def memory_status(self, object_id: str) -> Any:
+        """Which memories this object produced, and whether extraction finished."""
+        return self._request("GET", f"{_V2}/objects/{_seg(object_id)}/memory-status")
+
+    def structured_stats(self, object_id: str) -> Any:
+        """Row and column statistics for spreadsheet-shaped objects."""
+        return self._request("GET", f"{_V2}/objects/{_seg(object_id)}/structured-stats")
+
+    def evaluate(self, object_id: str, **body: Any) -> Any:
+        """Score this object for extraction worthiness without extracting."""
+        return self._request(
+            "POST", f"{_V2}/objects/{_seg(object_id)}/evaluate", json=body or None
+        )
+
+    def pause(self, object_id: str) -> Any:
+        """Stop re-syncing this object, leaving its memories in place."""
+        return self._request("POST", f"{_V2}/objects/{_seg(object_id)}/pause")
+
+    def resume(self, object_id: str) -> Any:
+        """Resume syncing a paused object."""
+        return self._request("POST", f"{_V2}/objects/{_seg(object_id)}/resume")
+
+    def reextract(self, object_id: str, **body: Any) -> Any:
+        """Run extraction again over content already fetched.
+
+        Counts against the plan's add allowance, exactly like the first
+        extraction, because it creates memories the same way.
+        """
+        return self._request(
+            "POST", f"{_V2}/objects/{_seg(object_id)}/reextract", json=body or None
+        )
+
+    def resync(self, object_id: str, **body: Any) -> Any:
+        """Fetch this object from the provider again, then extract."""
+        return self._request(
+            "POST", f"{_V2}/objects/{_seg(object_id)}/resync", json=body or None
+        )
+
+    def delete_memories(self, object_id: str, **params: Any) -> Any:
+        """Remove the memories this object produced, keeping the object record."""
+        return self._request(
+            "DELETE", f"{_V2}/objects/{_seg(object_id)}/memories", params=params or None
+        )
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Providers and sync jobs
+# ─────────────────────────────────────────────────────────────────────
+
+
+class ProvidersNamespace(_Namespace):
+    """Connectors this deployment supports. Awaitable on the async client."""
+
+    def list(self, **params: Any) -> Any:
+        """Every available provider and what it needs to connect."""
+        return self._request("GET", f"{_V2}/providers", params=params or None)
+
+    def get(self, provider_id: str) -> Any:
+        """One provider's capabilities, scopes and settings schema."""
+        return self._request("GET", f"{_V2}/providers/{_seg(provider_id)}")
+
+
+class SyncJobsNamespace(_Namespace):
+    """Individual sync runs. Awaitable on the async client."""
+
+    def get(self, job_id: str) -> Any:
+        """Progress and outcome of one sync run."""
+        return self._request("GET", f"{_V2}/sync-jobs/{_seg(job_id)}")
+
+    def cancel(self, job_id: str, **body: Any) -> Any:
+        """Stop a running sync. Objects already ingested are kept."""
+        return self._request(
+            "POST", f"{_V2}/sync-jobs/{_seg(job_id)}/cancel", json=body or None
+        )
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Web crawler
+# ─────────────────────────────────────────────────────────────────────
+
+
+class WebCrawlerNamespace(_Namespace):
+    """Turn websites into memories. Awaitable on the async client."""
+
+    def validate(self, url: str, **body: Any) -> Any:
+        """Check a URL is reachable and crawlable before committing to a job."""
+        payload: Dict[str, Any] = {"url": url}
+        payload.update(body)
+        return self._request("POST", f"{_V1}/web-crawler/validate", json=payload)
+
+    def crawl(self, url: str, **body: Any) -> Any:
+        """Start a crawl. Returns a job to poll.
+
+        Crawling only fetches and stores page content. Nothing becomes a memory
+        until you call :meth:`import_job`, so a large crawl cannot quietly consume
+        your add allowance.
+        """
+        payload: Dict[str, Any] = {"url": url}
+        payload.update(body)
+        return self._request("POST", f"{_V1}/web-crawler/crawl", json=payload)
+
+    def jobs(self, **params: Any) -> Any:
+        """Crawl jobs for this organization."""
+        return self._request("GET", f"{_V1}/web-crawler/jobs", params=params or None)
+
+    def job(self, job_id: str) -> Any:
+        """One crawl job's status and progress."""
+        return self._request("GET", f"{_V1}/web-crawler/jobs/{_seg(job_id)}")
+
+    def cancel_job(self, job_id: str) -> Any:
+        """Stop a running crawl. Pages already fetched are kept."""
+        return self._request("POST", f"{_V1}/web-crawler/jobs/{_seg(job_id)}/cancel")
+
+    def delete_job(self, job_id: str) -> Any:
+        """Delete a crawl job and its fetched pages."""
+        return self._request("DELETE", f"{_V1}/web-crawler/jobs/{_seg(job_id)}")
+
+    def job_content(self, job_id: str, **params: Any) -> Any:
+        """Pages a crawl fetched, before any import."""
+        return self._request(
+            "GET", f"{_V1}/web-crawler/jobs/{_seg(job_id)}/content", params=params or None
+        )
+
+    def job_statistics(self, job_id: str) -> Any:
+        """Page counts, byte totals and error breakdown for a crawl."""
+        return self._request("GET", f"{_V1}/web-crawler/jobs/{_seg(job_id)}/statistics")
+
+    def import_job(self, job_id: str, **body: Any) -> Any:
+        """Turn a completed crawl's pages into memories.
+
+        This is the step that creates memories, so this is the step that is
+        billed — one unit per memory created, like every other ingestion path.
+        """
+        return self._request(
+            "POST", f"{_V1}/web-crawler/jobs/{_seg(job_id)}/import", json=body or None
+        )
+
+    def active(self) -> Any:
+        """Crawls running right now."""
+        return self._request("GET", f"{_V1}/web-crawler/active")
+
+    def config(self) -> Any:
+        """Crawler limits in force: depth, page ceiling, rate, timeouts."""
+        return self._request("GET", f"{_V1}/web-crawler/config")
+
+
+# ─────────────────────────────────────────────────────────────────────
+# Legacy integrations surface
+# ─────────────────────────────────────────────────────────────────────
+
+
+class IntegrationsNamespace(_Namespace):
+    """The ``/api/v1/integrations`` surface. Awaitable on the async client.
+
+    Kept because the catalog and the web crawler live here and have no v2
+    equivalent. For connection lifecycle use ``client.connections``, which is the
+    current API — ``connected()`` and ``stats()`` below are the older, thinner
+    views of the same data.
+    """
+
+    def __init__(self, request: RequestFn) -> None:
+        super().__init__(request)
+        self.web_crawler = WebCrawlerNamespace(request)
+
+    def catalog(self, **params: Any) -> Any:
+        """Every integration this deployment offers, for building a picker UI."""
+        return self._request("GET", f"{_V1}/catalog", params=params or None)
+
+    def connected(self, **params: Any) -> Any:
+        """Integrations currently connected. Older view of ``connections.list()``."""
+        return self._request("GET", f"{_V1}/connected", params=params or None)
+
+    def stats(self, **params: Any) -> Any:
+        """Legacy integration counters. Prefer ``connections.stats()``."""
+        return self._request("GET", f"{_V1}/stats", params=params or None)
+
+    def update(self, integration_id: str, **body: Any) -> Any:
+        """Update a legacy integration record."""
+        return self._request("PATCH", f"{_V1}/{_seg(integration_id)}", json=body)
+
+    def delete(self, integration_id: str) -> Any:
+        """Delete a legacy integration record."""
+        return self._request("DELETE", f"{_V1}/{_seg(integration_id)}")
+
+
+__all__ = [
+    "ConnectionOAuthNamespace",
+    "ConnectionsNamespace",
+    "GoogleDriveNamespace",
+    "GranolaNamespace",
+    "IntegrationsNamespace",
+    "ObjectsNamespace",
+    "ProvidersNamespace",
+    "S3Namespace",
+    "SlackNamespace",
+    "SyncJobsNamespace",
+    "WebCrawlerNamespace",
+]

memorysync-1.2.0/src/memorysync/_version.py

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