memorysync 1.0.0__tar.gz → 1.1.0__tar.gz

memorysync-1.1.0/.gitignore

@@ -0,0 +1,48 @@
+# ==============================================================================
+# MemorySync — Git Ignore Rules (Transparency-First Philosophy)
+# ==============================================================================
+
+# -------------------------
+# Category 1: Secrets & Credentials (NEVER COMMIT)
+# -------------------------
+.env
+.env.*
+!memorysync-benchmark/longmemeval/.env.example
+*.pem
+*.key
+*.crt
+secrets/
+
+# -------------------------
+# Category 2: User / Customer / Private Data (NEVER COMMIT)
+# -------------------------
+uploads/
+backups/
+/storage/
+chroma/
+chroma_data/
+*.db
+*.sqlite
+*.sqlite3
+*.dump
+*.bak
+
+# -------------------------
+# Category 3: Massive Dependency / Build / Cache Artifacts (BLOAT)
+# -------------------------
+node_modules/
+venv/
+.venv/
+__pycache__/
+.pytest_cache/
+.next/
+dist/
+build/
+htmlcov/
+.coverage
+*.cover
+out/
+/dashboard/tsconfig.tsbuildinfo
+
+# Responsive audit output (regenerated by npm run audit:responsive)
+dashboard/responsive-audit-report.json

{memorysync-1.0.0 → memorysync-1.1.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: memorysync
-Version: 1.0.0
+Version: 1.1.0
 Summary: Official Python client for the MemorySync API.
-Project-URL: Homepage, https://memorysync.dev
-Project-URL: Documentation, https://memorysync.dev/docs
+Project-URL: Homepage, https://memorysync.io
+Project-URL: Documentation, https://docs.memorysync.io
 Author: MemorySync
 License: MIT
 License-File: LICENSE
@@ -38,7 +38,7 @@ from memorysync import MemorySyncClient
 
 ms = MemorySyncClient(
     api_key="...",
-    base_url="https://api.memorysync.dev",
+    base_url="https://api.memorysync.io",
     project_id="proj_xxxxxxxxxxxxxxxx",   # optional
     end_user_id="user_42",                 # optional
 )
@@ -119,6 +119,61 @@ else:
     print(result.id, result.text)
 ```
 
+## Control-plane client
+
+Dashboard and administrative routes use bearer authentication, not the memory
+client's API key. Tokens are never persisted or refreshed automatically.
+Responses are typed dictionaries with snake_case keys, including routes whose
+wire response uses camelCase.
+
+```python
+import os
+from memorysync import ControlPlaneClient
+
+with ControlPlaneClient(
+    "https://api.memorysync.io",
+    access_token=os.environ["MEMORYSYNC_ACCESS_TOKEN"],
+    project_id="project_abc123",  # optional X-Project-ID default
+) as control:
+    members = control.list_team_members()
+    hooks = control.list_webhooks()
+
+# Login is the only operation that does not require a configured token.
+with ControlPlaneClient("https://api.memorysync.io") as control:
+    login = control.login("developer@example.com", os.environ["MEMORYSYNC_PASSWORD"])
+```
+
+`AsyncControlPlaneClient` exposes the same methods with `await` and `aclose()`.
+Both clients accept `base_url`, optional `access_token`, optional `project_id`,
+`timeout`, and an injectable sync/async `httpx` `transport`. Project-scoped
+operations accept a per-call `project_id` override.
+
+| Method | HTTP route |
+| --- | --- |
+| `bulk_revoke_api_keys` | `POST /org/api-keys/bulk-revoke` |
+| `test_api_key` | `POST /org/api-keys/{key_id}/test` |
+| `login` | `POST /auth/login` |
+| `get_current_plan` | `GET /org/billing/current-plan` |
+| `list_team_members` | `GET /admin/team/members` |
+| `suspend_team_member` | `PATCH /admin/team/members/{member_id}` |
+| `remove_team_member` | `DELETE /admin/team/members/{member_id}` |
+| `list_sessions` | `GET /auth/sessions` |
+| `revoke_session` | `POST /auth/sessions/{session_id}/revoke` |
+| `list_audit_events` | `GET /admin/audit-logs` |
+| `list_integrations` | `GET /api/v1/integrations/catalog` |
+| `create_organization` | `POST /organizations` |
+| `list_organizations` | `GET /organizations` |
+| `list_organization_members` | delegates to `list_team_members` |
+| `get_organization_settings` | `GET /admin/tenant-settings` |
+| `list_projects` | `GET /org/projects` |
+| `create_webhook` | `POST /org/webhooks` |
+| `list_webhooks` | `GET /org/webhooks` |
+| `update_webhook` | `PATCH /org/webhooks/{endpoint_id}` |
+| `delete_webhook` | `DELETE /org/webhooks/{endpoint_id}` |
+| `test_webhook` | `POST /org/webhooks/{endpoint_id}/test` |
+| `replay_webhook_deliveries` | `POST /org/webhooks/{endpoint_id}/replay` |
+| `list_webhook_deliveries` | `GET /org/webhooks/{endpoint_id}/deliveries` |
+
 ## Errors
 
 Every non-2xx response raises a typed subclass of `MemorySyncError`:

{memorysync-1.0.0 → memorysync-1.1.0}/README.md

@@ -13,7 +13,7 @@ from memorysync import MemorySyncClient
 
 ms = MemorySyncClient(
     api_key="...",
-    base_url="https://api.memorysync.dev",
+    base_url="https://api.memorysync.io",
     project_id="proj_xxxxxxxxxxxxxxxx",   # optional
     end_user_id="user_42",                 # optional
 )
@@ -94,6 +94,61 @@ else:
     print(result.id, result.text)
 ```
 
+## Control-plane client
+
+Dashboard and administrative routes use bearer authentication, not the memory
+client's API key. Tokens are never persisted or refreshed automatically.
+Responses are typed dictionaries with snake_case keys, including routes whose
+wire response uses camelCase.
+
+```python
+import os
+from memorysync import ControlPlaneClient
+
+with ControlPlaneClient(
+    "https://api.memorysync.io",
+    access_token=os.environ["MEMORYSYNC_ACCESS_TOKEN"],
+    project_id="project_abc123",  # optional X-Project-ID default
+) as control:
+    members = control.list_team_members()
+    hooks = control.list_webhooks()
+
+# Login is the only operation that does not require a configured token.
+with ControlPlaneClient("https://api.memorysync.io") as control:
+    login = control.login("developer@example.com", os.environ["MEMORYSYNC_PASSWORD"])
+```
+
+`AsyncControlPlaneClient` exposes the same methods with `await` and `aclose()`.
+Both clients accept `base_url`, optional `access_token`, optional `project_id`,
+`timeout`, and an injectable sync/async `httpx` `transport`. Project-scoped
+operations accept a per-call `project_id` override.
+
+| Method | HTTP route |
+| --- | --- |
+| `bulk_revoke_api_keys` | `POST /org/api-keys/bulk-revoke` |
+| `test_api_key` | `POST /org/api-keys/{key_id}/test` |
+| `login` | `POST /auth/login` |
+| `get_current_plan` | `GET /org/billing/current-plan` |
+| `list_team_members` | `GET /admin/team/members` |
+| `suspend_team_member` | `PATCH /admin/team/members/{member_id}` |
+| `remove_team_member` | `DELETE /admin/team/members/{member_id}` |
+| `list_sessions` | `GET /auth/sessions` |
+| `revoke_session` | `POST /auth/sessions/{session_id}/revoke` |
+| `list_audit_events` | `GET /admin/audit-logs` |
+| `list_integrations` | `GET /api/v1/integrations/catalog` |
+| `create_organization` | `POST /organizations` |
+| `list_organizations` | `GET /organizations` |
+| `list_organization_members` | delegates to `list_team_members` |
+| `get_organization_settings` | `GET /admin/tenant-settings` |
+| `list_projects` | `GET /org/projects` |
+| `create_webhook` | `POST /org/webhooks` |
+| `list_webhooks` | `GET /org/webhooks` |
+| `update_webhook` | `PATCH /org/webhooks/{endpoint_id}` |
+| `delete_webhook` | `DELETE /org/webhooks/{endpoint_id}` |
+| `test_webhook` | `POST /org/webhooks/{endpoint_id}/test` |
+| `replay_webhook_deliveries` | `POST /org/webhooks/{endpoint_id}/replay` |
+| `list_webhook_deliveries` | `GET /org/webhooks/{endpoint_id}/deliveries` |
+
 ## Errors
 
 Every non-2xx response raises a typed subclass of `MemorySyncError`:

{memorysync-1.0.0 → memorysync-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memorysync"
-version = "1.0.0"
+version = "1.1.0"
 description = "Official Python client for the MemorySync API."
 readme = "README.md"
 license = { text = "MIT" }
@@ -29,8 +29,8 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://memorysync.dev"
-Documentation = "https://memorysync.dev/docs"
+Homepage = "https://memorysync.io"
+Documentation = "https://docs.memorysync.io"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/memorysync"]

memorysync-1.1.0/src/memorysync/__init__.py

@@ -0,0 +1,94 @@
+"""Public package surface for the MemorySync Python SDK."""
+
+from ._version import __version__
+from .errors import (
+    AuthError,
+    MemorySyncError,
+    NotFoundError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+from .types import (
+    AddSkippedResponse,
+    BulkAddItem,
+    BulkAddItemResult,
+    BulkAddResponse,
+    ComposeResponse,
+    ExportResponse,
+    Memory,
+    QueryResponse,
+    Relation,
+    RelationshipType,
+)
+from .client import AsyncMemorySyncClient, MemorySyncClient
+from .control_plane import AsyncControlPlaneClient, ControlPlaneClient
+from .control_plane_types import (
+    ApiKeyTestResponse,
+    AuditEvent,
+    AuditEventsResponse,
+    BulkRevokeRequest,
+    BulkRevokeResponse,
+    BulkRevokeResult,
+    CreateOrganizationRequest,
+    CreateWebhookRequest,
+    CurrentPlanResponse,
+    Integration,
+    JsonObject,
+    LoginRequest,
+    LoginResponse,
+    LoginSession,
+    LoginTokens,
+    OrganizationMembership,
+    OrganizationSettings,
+    Project,
+    ReplayWebhookDeliveriesRequest,
+    Session,
+    SessionsResponse,
+    TeamMember,
+    TestWebhookRequest,
+    UpdateWebhookRequest,
+    Webhook,
+    WebhookDeliveriesResponse,
+    WebhookDelivery,
+    WebhookReplayResponse,
+    WebhooksResponse,
+    WebhookTestResponse,
+)
+
+__all__ = [
+    "__version__",
+    "MemorySyncClient",
+    "AsyncMemorySyncClient",
+    "Memory",
+    "QueryResponse",
+    "BulkAddItem",
+    "BulkAddItemResult",
+    "BulkAddResponse",
+    "AddSkippedResponse",
+    "ComposeResponse",
+    "ExportResponse",
+    "Relation",
+    "RelationshipType",
+    "MemorySyncError",
+    "AuthError",
+    "ValidationError",
+    "NotFoundError",
+    "RateLimitError",
+    "ServerError",
+]
+
+
+__all__ += [
+    "ControlPlaneClient", "AsyncControlPlaneClient", "JsonObject",
+    "BulkRevokeRequest", "BulkRevokeResult", "BulkRevokeResponse",
+    "ApiKeyTestResponse", "LoginRequest", "LoginTokens", "LoginSession",
+    "LoginResponse", "CurrentPlanResponse", "TeamMember", "Session",
+    "SessionsResponse", "AuditEvent", "AuditEventsResponse", "Integration",
+    "CreateOrganizationRequest", "OrganizationMembership",
+    "OrganizationSettings", "Project", "CreateWebhookRequest",
+    "UpdateWebhookRequest", "TestWebhookRequest",
+    "ReplayWebhookDeliveriesRequest", "Webhook", "WebhooksResponse",
+    "WebhookTestResponse", "WebhookReplayResponse", "WebhookDelivery",
+    "WebhookDeliveriesResponse",
+]

memorysync-1.1.0/src/memorysync/_version.py

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

memorysync-1.1.0/src/memorysync/control_plane.py

@@ -0,0 +1,629 @@
+"""Bearer-authenticated clients for MemorySync control-plane REST routes."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+from typing import Any, Dict, List, Mapping, Optional, Sequence, TypeVar, cast
+from urllib.parse import urlparse
+
+import httpx
+
+from ._version import __version__
+from .control_plane_types import (
+    ApiKeyTestResponse, AuditEventsResponse, BulkRevokeResponse,
+    CurrentPlanResponse, Integration, LoginResponse, OrganizationMembership,
+    OrganizationSettings, Project, Session, SessionsResponse, TeamMember,
+    Webhook, WebhookDeliveriesResponse, WebhookReplayResponse,
+    WebhooksResponse, WebhookTestResponse,
+)
+from .errors import (
+    AuthError, MemorySyncError, NotFoundError, RateLimitError, ServerError,
+    ValidationError,
+)
+
+_USER_AGENT = f"memorysync-sdk-py/{__version__}"
+_T = TypeVar("_T")
+_UNSET = object()
+
+
+def _positive_id(value: Any, name: str) -> int:
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise ValidationError(f"{name} must be a positive integer")
+    return value
+
+
+def _required_text(value: str, name: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ValidationError(f"{name} must be a non-empty string")
+    return value
+
+
+def _bounded(value: int, name: str, minimum: int, maximum: int) -> int:
+    if not isinstance(value, int) or isinstance(value, bool) or not minimum <= value <= maximum:
+        raise ValidationError(f"{name} must be an integer between {minimum} and {maximum}")
+    return value
+
+
+def _project(value: Optional[str], name: str = "project_id") -> Optional[str]:
+    if value is not None:
+        _required_text(value, name)
+    return value
+
+
+def _body(**values: Any) -> Dict[str, Any]:
+    return {key: value for key, value in values.items() if value is not None}
+
+
+def _snake_key(key: str) -> str:
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", key).lower()
+
+
+def _snake(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {_snake_key(str(key)): _snake(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_snake(item) for item in value]
+    return value
+
+
+def _detail(body: Any) -> Optional[str]:
+    if not isinstance(body, dict):
+        return None
+    detail = body.get("detail")
+    if isinstance(detail, str):
+        return detail
+    error = body.get("error")
+    if isinstance(error, dict) and isinstance(error.get("message"), str):
+        return cast(str, error["message"])
+    if isinstance(detail, list) and detail and isinstance(detail[0], dict):
+        message = detail[0].get("msg")
+        return message if isinstance(message, str) else None
+    return None
+
+
+def _retry_after(headers: Mapping[str, str], body: Any) -> float:
+    raw = headers.get("retry-after")
+    if raw:
+        try:
+            return max(0.0, float(raw))
+        except ValueError:
+            try:
+                when = parsedate_to_datetime(raw)
+                if when.tzinfo is None:
+                    when = when.replace(tzinfo=timezone.utc)
+                return max(0.0, (when - datetime.now(timezone.utc)).total_seconds())
+            except (TypeError, ValueError, OverflowError):
+                pass
+    if isinstance(body, dict):
+        value = body.get("retry_after")
+        error = body.get("error")
+        if value is None and isinstance(error, dict):
+            value = error.get("retry_after")
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            return max(0.0, float(value))
+    return 0.0
+
+
+def _raise_response(response: httpx.Response, body: Any) -> None:
+    status = response.status_code
+    request_id = response.headers.get("x-request-id") or response.headers.get("request-id")
+    kwargs = {"status_code": status, "response": body, "request_id": request_id}
+    message = _detail(body)
+    if status in (401, 403):
+        raise AuthError(message or ("Unauthenticated" if status == 401 else "Forbidden"), **kwargs)
+    if status == 404:
+        raise NotFoundError(message or "Not found", **kwargs)
+    if status in (400, 409, 422):
+        raise ValidationError(message or "Validation error", **kwargs)
+    if status == 429:
+        raise RateLimitError(message or "Rate limited", _retry_after(response.headers, body), **kwargs)
+    if status >= 500:
+        raise ServerError(message or f"Server error ({status})", **kwargs)
+    raise MemorySyncError(message or f"Unexpected status {status}", **kwargs)
+
+
+class _ControlPlaneBase:
+    def __init__(self, base_url: str, access_token: Optional[str], project_id: Optional[str]) -> None:
+        self._base_url = _required_text(base_url, "base_url").rstrip("/")
+        parsed_base = urlparse(self._base_url)
+        if parsed_base.scheme not in ("http", "https") or not parsed_base.netloc:
+            raise ValidationError("base_url must be an absolute HTTP or HTTPS URL")
+        self._access_token = access_token
+        if access_token is not None:
+            _required_text(access_token, "access_token")
+        self._project_id = _project(project_id)
+
+    def _headers(
+        self, *, require_auth: bool = True, project_id: object = _UNSET
+    ) -> Dict[str, str]:
+        headers = {"Accept": "application/json", "User-Agent": _USER_AGENT}
+        if require_auth:
+            if not self._access_token:
+                raise AuthError("access_token is required for this operation")
+            headers["Authorization"] = f"Bearer {self._access_token}"
+        selected = self._project_id if project_id is _UNSET else cast(Optional[str], project_id)
+        if selected is not None:
+            headers["X-Project-ID"] = cast(str, _project(selected))
+        return headers
+
+    @staticmethod
+    def _decode(response: httpx.Response) -> Any:
+        if response.status_code == 204:
+            return None
+        try:
+            raw: Any = response.json()
+        except ValueError:
+            raw = response.text or None
+        if response.status_code >= 400:
+            _raise_response(response, raw)
+        return _snake(raw)
+
+
+def _validate_webhook(name: str, url: str, events: Sequence[str]) -> None:
+    _required_text(name, "name")
+    if len(name) > 128:
+        raise ValidationError("name may contain at most 128 characters")
+    _required_text(url, "url")
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https") or not parsed.netloc:
+        raise ValidationError("url must be an absolute HTTP or HTTPS URL")
+    if not events or any(not isinstance(event, str) or not event.strip() for event in events):
+        raise ValidationError("events must contain at least one non-empty string")
+
+
+class ControlPlaneClient(_ControlPlaneBase):
+    """Synchronous bearer client for dashboard/control-plane routes."""
+
+    def __init__(
+        self, base_url: str, *, access_token: Optional[str] = None,
+        project_id: Optional[str] = None, timeout: float = 30.0,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        super().__init__(base_url, access_token, project_id)
+        self._http = httpx.Client(timeout=timeout, transport=transport)
+
+    def __enter__(self) -> "ControlPlaneClient":
+        return self
+
+    def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _request(
+        self, method: str, path: str, *, json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None, require_auth: bool = True,
+        project_id: object = _UNSET,
+    ) -> Any:
+        try:
+            response = self._http.request(
+                method, f"{self._base_url}{path}",
+                headers=self._headers(require_auth=require_auth, project_id=project_id),
+                json=json, params=params,
+            )
+        except httpx.TimeoutException as exc:
+            raise MemorySyncError("Control-plane request timed out") from exc
+        except httpx.HTTPError as exc:
+            raise MemorySyncError("Control-plane network request failed") from exc
+        return self._decode(response)
+
+    def bulk_revoke_api_keys(
+        self, key_ids: Sequence[int], *, project_id: Optional[str] = None
+    ) -> BulkRevokeResponse:
+        ids = list(key_ids)
+        if not 1 <= len(ids) <= 100:
+            raise ValidationError("key_ids must contain between 1 and 100 entries")
+        for key_id in ids:
+            _positive_id(key_id, "key_id")
+        raw = self._request("POST", "/org/api-keys/bulk-revoke", json={"key_ids": ids}, project_id=project_id or _UNSET)
+        return cast(BulkRevokeResponse, raw)
+
+    def test_api_key(self, key_id: int, *, project_id: Optional[str] = None) -> ApiKeyTestResponse:
+        raw = self._request("POST", f"/org/api-keys/{_positive_id(key_id, 'key_id')}/test", project_id=project_id or _UNSET)
+        return cast(ApiKeyTestResponse, raw)
+
+    def login(self, email: str, password: str) -> LoginResponse:
+        _required_text(email, "email")
+        if "@" not in email:
+            raise ValidationError("email must be a valid email address")
+        _required_text(password, "password")
+        return cast(LoginResponse, self._request("POST", "/auth/login", json={"email": email, "password": password}, require_auth=False, project_id=None))
+
+    def get_current_plan(self) -> CurrentPlanResponse:
+        return cast(CurrentPlanResponse, self._request("GET", "/org/billing/current-plan"))
+
+    def list_team_members(self) -> List[TeamMember]:
+        return cast(List[TeamMember], self._request("GET", "/admin/team/members"))
+
+    def suspend_team_member(self, member_id: int) -> TeamMember:
+        path = f"/admin/team/members/{_positive_id(member_id, 'member_id')}"
+        return cast(TeamMember, self._request("PATCH", path, json={"status": "suspended"}))
+
+    def remove_team_member(self, member_id: int) -> None:
+        path = f"/admin/team/members/{_positive_id(member_id, 'member_id')}"
+        self._request("DELETE", path)
+
+    def list_sessions(self) -> SessionsResponse:
+        return cast(SessionsResponse, self._request("GET", "/auth/sessions"))
+
+    def revoke_session(self, session_id: int) -> None:
+        self._request("POST", f"/auth/sessions/{_positive_id(session_id, 'session_id')}/revoke")
+
+
+    def list_audit_events(
+        self, *, limit: Optional[int] = None, cursor: Optional[int] = None,
+        skip: Optional[int] = None, sort_direction: Optional[str] = None,
+        tenant_id: Optional[str] = None, actor: Optional[str] = None,
+        actor_email: Optional[str] = None, ip: Optional[str] = None,
+        action: Optional[str] = None, resource_type: Optional[str] = None,
+        resource_id: Optional[str] = None, severity: Optional[str] = None,
+        category: Optional[str] = None, start: Optional[str] = None,
+        end: Optional[str] = None, success: Optional[bool] = None,
+        source: Optional[str] = None, ingest_method: Optional[str] = None,
+        search: Optional[str] = None, include_stats: Optional[bool] = None,
+    ) -> AuditEventsResponse:
+        if limit is not None:
+            _bounded(limit, "limit", 1, 200)
+        if cursor is not None and cursor < 0:
+            raise ValidationError("cursor must be non-negative")
+        if skip is not None and skip < 0:
+            raise ValidationError("skip must be non-negative")
+        if sort_direction not in (None, "asc", "desc"):
+            raise ValidationError("sort_direction must be 'asc' or 'desc'")
+        params = _body(limit=limit, cursor=cursor, skip=skip, sort=sort_direction,
+                       tenant_id=tenant_id, actor=actor, actor_email=actor_email,
+                       ip=ip, action=action, resource_type=resource_type,
+                       resource_id=resource_id, severity=severity, category=category,
+                       start=start, end=end, success=success, source=source,
+                       ingest_method=ingest_method, search=search,
+                       include_stats=include_stats)
+        raw = self._request("GET", "/admin/audit-logs", params=params)
+        return cast(AuditEventsResponse, {
+            "events": raw.get("logs", []),
+            "next_cursor": raw.get("next_cursor"),
+            "stats": raw.get("stats"),
+            "sort": raw.get("sort", sort_direction or "desc"),
+        })
+
+    def list_integrations(self, *, category: Optional[str] = None) -> List[Integration]:
+        if category is not None:
+            _required_text(category, "category")
+        return cast(List[Integration], self._request("GET", "/api/v1/integrations/catalog", params=_body(category=category)))
+
+    def create_organization(self, name: str, *, domain: Optional[str] = None) -> OrganizationMembership:
+        _required_text(name, "name")
+        if domain is not None:
+            _required_text(domain, "domain")
+        return cast(OrganizationMembership, self._request("POST", "/organizations", json=_body(name=name, domain=domain)))
+
+    def list_organizations(self) -> List[OrganizationMembership]:
+        return cast(List[OrganizationMembership], self._request("GET", "/organizations"))
+
+    def list_organization_members(self) -> List[TeamMember]:
+        return self.list_team_members()
+
+    def get_organization_settings(self, *, tenant_id: Optional[str] = None) -> OrganizationSettings:
+        if tenant_id is not None:
+            _required_text(tenant_id, "tenant_id")
+        return cast(OrganizationSettings, self._request("GET", "/admin/tenant-settings", params=_body(tenant_id=tenant_id)))
+
+    def list_projects(self) -> List[Project]:
+        return cast(List[Project], self._request("GET", "/org/projects"))
+
+    def create_webhook(
+        self, name: str, url: str, events: Sequence[str], *,
+        description: Optional[str] = None, retry_config: Optional[Dict[str, Any]] = None,
+        signature_config: Optional[Dict[str, Any]] = None,
+        project_id: Optional[str] = None,
+    ) -> Webhook:
+        _validate_webhook(name, url, events)
+        if description is not None and len(description) > 500:
+            raise ValidationError("description may contain at most 500 characters")
+        selected = project_id or self._project_id
+        data = _body(name=name, url=url, events=list(events), description=description,
+                     retry_config=retry_config, signature_config=signature_config,
+                     project_id=project_id)
+        return cast(Webhook, self._request("POST", "/org/webhooks", json=data, project_id=selected))
+
+    def list_webhooks(self, *, project_id: Optional[str] = None) -> WebhooksResponse:
+        return cast(WebhooksResponse, self._request("GET", "/org/webhooks", project_id=project_id or _UNSET))
+
+
+    def update_webhook(
+        self, endpoint_id: int, *, name: Optional[str] = None,
+        url: Optional[str] = None, description: Optional[str] = None,
+        events: Optional[Sequence[str]] = None,
+        retry_config: Optional[Dict[str, Any]] = None,
+        signature_config: Optional[Dict[str, Any]] = None,
+        project_id: Optional[str] = None,
+    ) -> Webhook:
+        if name is not None:
+            _required_text(name, "name")
+            if len(name) > 128:
+                raise ValidationError("name may contain at most 128 characters")
+        if url is not None:
+            parsed = urlparse(url)
+            if parsed.scheme not in ("http", "https") or not parsed.netloc:
+                raise ValidationError("url must be an absolute HTTP or HTTPS URL")
+        if description is not None and len(description) > 500:
+            raise ValidationError("description may contain at most 500 characters")
+        if events is not None and (not events or any(not event.strip() for event in events)):
+            raise ValidationError("events must contain at least one non-empty string")
+        data = _body(name=name, url=url, description=description,
+                     events=list(events) if events is not None else None,
+                     retry_config=retry_config, signature_config=signature_config)
+        if not data:
+            raise ValidationError("update_webhook requires at least one editable field")
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
+        return cast(Webhook, self._request("PATCH", path, json=data, project_id=project_id or _UNSET))
+
+    def delete_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> None:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
+        self._request("DELETE", path, project_id=project_id or _UNSET)
+
+    def test_webhook(
+        self, endpoint_id: int, *, event_type: str = "memory.created",
+        project_id: Optional[str] = None,
+    ) -> WebhookTestResponse:
+        _required_text(event_type, "event_type")
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/test"
+        return cast(WebhookTestResponse, self._request("POST", path, json={"event_type": event_type}, project_id=project_id or _UNSET))
+
+    def replay_webhook_deliveries(
+        self, endpoint_id: int, *, since_minutes: int = 60,
+        statuses: Sequence[str] = ("failed", "dead_letter"), limit: int = 100,
+        project_id: Optional[str] = None,
+    ) -> WebhookReplayResponse:
+        _bounded(since_minutes, "since_minutes", 1, 10080)
+        _bounded(limit, "limit", 1, 1000)
+        if not statuses or any(not isinstance(status, str) or not status.strip() for status in statuses):
+            raise ValidationError("statuses must contain at least one non-empty string")
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/replay"
+        data = {"since_minutes": since_minutes, "statuses": list(statuses), "limit": limit}
+        return cast(WebhookReplayResponse, self._request("POST", path, json=data, project_id=project_id or _UNSET))
+
+    def list_webhook_deliveries(
+        self, endpoint_id: int, *, page: int = 1, page_size: int = 25,
+        status: Optional[str] = None, project_id: Optional[str] = None,
+    ) -> WebhookDeliveriesResponse:
+        _positive_id(page, "page")
+        _bounded(page_size, "page_size", 1, 100)
+        if status is not None:
+            _required_text(status, "status")
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/deliveries"
+        params = _body(page=page, page_size=page_size, status_filter=status)
+        return cast(WebhookDeliveriesResponse, self._request("GET", path, params=params, project_id=project_id or _UNSET))
+
+
+class AsyncControlPlaneClient(_ControlPlaneBase):
+    """Async-native bearer client for dashboard/control-plane routes."""
+
+    def __init__(
+        self, base_url: str, *, access_token: Optional[str] = None,
+        project_id: Optional[str] = None, timeout: float = 30.0,
+        transport: Optional[httpx.AsyncBaseTransport] = None,
+    ) -> None:
+        super().__init__(base_url, access_token, project_id)
+        self._http = httpx.AsyncClient(timeout=timeout, transport=transport)
+
+    async def __aenter__(self) -> "AsyncControlPlaneClient":
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def _request(
+        self, method: str, path: str, *, json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None, require_auth: bool = True,
+        project_id: object = _UNSET,
+    ) -> Any:
+        try:
+            response = await self._http.request(
+                method, f"{self._base_url}{path}",
+                headers=self._headers(require_auth=require_auth, project_id=project_id),
+                json=json, params=params,
+            )
+        except httpx.TimeoutException as exc:
+            raise MemorySyncError("Control-plane request timed out") from exc
+        except httpx.HTTPError as exc:
+            raise MemorySyncError("Control-plane network request failed") from exc
+        return self._decode(response)
+
+    async def bulk_revoke_api_keys(self, key_ids: Sequence[int], *, project_id: Optional[str] = None) -> BulkRevokeResponse:
+        ids = list(key_ids)
+        if not 1 <= len(ids) <= 100:
+            raise ValidationError("key_ids must contain between 1 and 100 entries")
+        for key_id in ids:
+            _positive_id(key_id, "key_id")
+        raw = await self._request("POST", "/org/api-keys/bulk-revoke", json={"key_ids": ids}, project_id=project_id or _UNSET)
+        return cast(BulkRevokeResponse, raw)
+
+    async def test_api_key(self, key_id: int, *, project_id: Optional[str] = None) -> ApiKeyTestResponse:
+        raw = await self._request("POST", f"/org/api-keys/{_positive_id(key_id, 'key_id')}/test", project_id=project_id or _UNSET)
+        return cast(ApiKeyTestResponse, raw)
+
+    async def login(self, email: str, password: str) -> LoginResponse:
+        _required_text(email, "email")
+        if "@" not in email:
+            raise ValidationError("email must be a valid email address")
+        _required_text(password, "password")
+        raw = await self._request("POST", "/auth/login", json={"email": email, "password": password}, require_auth=False, project_id=None)
+        return cast(LoginResponse, raw)
+
+    async def get_current_plan(self) -> CurrentPlanResponse:
+        return cast(CurrentPlanResponse, await self._request("GET", "/org/billing/current-plan"))
+
+    async def list_team_members(self) -> List[TeamMember]:
+        return cast(List[TeamMember], await self._request("GET", "/admin/team/members"))
+
+    async def suspend_team_member(self, member_id: int) -> TeamMember:
+        path = f"/admin/team/members/{_positive_id(member_id, 'member_id')}"
+        return cast(TeamMember, await self._request("PATCH", path, json={"status": "suspended"}))
+
+    async def remove_team_member(self, member_id: int) -> None:
+        await self._request("DELETE", f"/admin/team/members/{_positive_id(member_id, 'member_id')}")
+
+    async def list_sessions(self) -> SessionsResponse:
+        return cast(SessionsResponse, await self._request("GET", "/auth/sessions"))
+
+    async def revoke_session(self, session_id: int) -> None:
+        await self._request("POST", f"/auth/sessions/{_positive_id(session_id, 'session_id')}/revoke")
+
+
+    async def list_audit_events(
+        self, *, limit: Optional[int] = None, cursor: Optional[int] = None,
+        skip: Optional[int] = None, sort_direction: Optional[str] = None,
+        tenant_id: Optional[str] = None, actor: Optional[str] = None,
+        actor_email: Optional[str] = None, ip: Optional[str] = None,
+        action: Optional[str] = None, resource_type: Optional[str] = None,
+        resource_id: Optional[str] = None, severity: Optional[str] = None,
+        category: Optional[str] = None, start: Optional[str] = None,
+        end: Optional[str] = None, success: Optional[bool] = None,
+        source: Optional[str] = None, ingest_method: Optional[str] = None,
+        search: Optional[str] = None, include_stats: Optional[bool] = None,
+    ) -> AuditEventsResponse:
+        if limit is not None:
+            _bounded(limit, "limit", 1, 200)
+        if cursor is not None and cursor < 0:
+            raise ValidationError("cursor must be non-negative")
+        if skip is not None and skip < 0:
+            raise ValidationError("skip must be non-negative")
+        if sort_direction not in (None, "asc", "desc"):
+            raise ValidationError("sort_direction must be 'asc' or 'desc'")
+        params = _body(limit=limit, cursor=cursor, skip=skip, sort=sort_direction,
+                       tenant_id=tenant_id, actor=actor, actor_email=actor_email,
+                       ip=ip, action=action, resource_type=resource_type,
+                       resource_id=resource_id, severity=severity, category=category,
+                       start=start, end=end, success=success, source=source,
+                       ingest_method=ingest_method, search=search,
+                       include_stats=include_stats)
+        raw = await self._request("GET", "/admin/audit-logs", params=params)
+        return cast(AuditEventsResponse, {
+            "events": raw.get("logs", []),
+            "next_cursor": raw.get("next_cursor"),
+            "stats": raw.get("stats"),
+            "sort": raw.get("sort", sort_direction or "desc"),
+        })
+
+    async def list_integrations(self, *, category: Optional[str] = None) -> List[Integration]:
+        if category is not None:
+            _required_text(category, "category")
+        raw = await self._request("GET", "/api/v1/integrations/catalog", params=_body(category=category))
+        return cast(List[Integration], raw)
+
+    async def create_organization(self, name: str, *, domain: Optional[str] = None) -> OrganizationMembership:
+        _required_text(name, "name")
+        if domain is not None:
+            _required_text(domain, "domain")
+        raw = await self._request("POST", "/organizations", json=_body(name=name, domain=domain))
+        return cast(OrganizationMembership, raw)
+
+    async def list_organizations(self) -> List[OrganizationMembership]:
+        return cast(List[OrganizationMembership], await self._request("GET", "/organizations"))
+
+    async def list_organization_members(self) -> List[TeamMember]:
+        return await self.list_team_members()
+
+    async def get_organization_settings(self, *, tenant_id: Optional[str] = None) -> OrganizationSettings:
+        if tenant_id is not None:
+            _required_text(tenant_id, "tenant_id")
+        raw = await self._request("GET", "/admin/tenant-settings", params=_body(tenant_id=tenant_id))
+        return cast(OrganizationSettings, raw)
+
+    async def list_projects(self) -> List[Project]:
+        return cast(List[Project], await self._request("GET", "/org/projects"))
+
+    async def create_webhook(
+        self, name: str, url: str, events: Sequence[str], *,
+        description: Optional[str] = None, retry_config: Optional[Dict[str, Any]] = None,
+        signature_config: Optional[Dict[str, Any]] = None,
+        project_id: Optional[str] = None,
+    ) -> Webhook:
+        _validate_webhook(name, url, events)
+        if description is not None and len(description) > 500:
+            raise ValidationError("description may contain at most 500 characters")
+        selected = project_id or self._project_id
+        data = _body(name=name, url=url, events=list(events), description=description,
+                     retry_config=retry_config, signature_config=signature_config,
+                     project_id=project_id)
+        raw = await self._request("POST", "/org/webhooks", json=data, project_id=selected)
+        return cast(Webhook, raw)
+
+    async def list_webhooks(self, *, project_id: Optional[str] = None) -> WebhooksResponse:
+        return cast(WebhooksResponse, await self._request("GET", "/org/webhooks", project_id=project_id or _UNSET))
+
+
+    async def update_webhook(
+        self, endpoint_id: int, *, name: Optional[str] = None,
+        url: Optional[str] = None, description: Optional[str] = None,
+        events: Optional[Sequence[str]] = None,
+        retry_config: Optional[Dict[str, Any]] = None,
+        signature_config: Optional[Dict[str, Any]] = None,
+        project_id: Optional[str] = None,
+    ) -> Webhook:
+        if name is not None:
+            _required_text(name, "name")
+            if len(name) > 128:
+                raise ValidationError("name may contain at most 128 characters")
+        if url is not None:
+            parsed = urlparse(url)
+            if parsed.scheme not in ("http", "https") or not parsed.netloc:
+                raise ValidationError("url must be an absolute HTTP or HTTPS URL")
+        if description is not None and len(description) > 500:
+            raise ValidationError("description may contain at most 500 characters")
+        if events is not None and (not events or any(not event.strip() for event in events)):
+            raise ValidationError("events must contain at least one non-empty string")
+        data = _body(name=name, url=url, description=description,
+                     events=list(events) if events is not None else None,
+                     retry_config=retry_config, signature_config=signature_config)
+        if not data:
+            raise ValidationError("update_webhook requires at least one editable field")
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
+        raw = await self._request("PATCH", path, json=data, project_id=project_id or _UNSET)
+        return cast(Webhook, raw)
+
+    async def delete_webhook(self, endpoint_id: int, *, project_id: Optional[str] = None) -> None:
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}"
+        await self._request("DELETE", path, project_id=project_id or _UNSET)
+
+    async def test_webhook(
+        self, endpoint_id: int, *, event_type: str = "memory.created",
+        project_id: Optional[str] = None,
+    ) -> WebhookTestResponse:
+        _required_text(event_type, "event_type")
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/test"
+        raw = await self._request("POST", path, json={"event_type": event_type}, project_id=project_id or _UNSET)
+        return cast(WebhookTestResponse, raw)
+
+    async def replay_webhook_deliveries(
+        self, endpoint_id: int, *, since_minutes: int = 60,
+        statuses: Sequence[str] = ("failed", "dead_letter"), limit: int = 100,
+        project_id: Optional[str] = None,
+    ) -> WebhookReplayResponse:
+        _bounded(since_minutes, "since_minutes", 1, 10080)
+        _bounded(limit, "limit", 1, 1000)
+        if not statuses or any(not isinstance(status, str) or not status.strip() for status in statuses):
+            raise ValidationError("statuses must contain at least one non-empty string")
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/replay"
+        data = {"since_minutes": since_minutes, "statuses": list(statuses), "limit": limit}
+        raw = await self._request("POST", path, json=data, project_id=project_id or _UNSET)
+        return cast(WebhookReplayResponse, raw)
+
+    async def list_webhook_deliveries(
+        self, endpoint_id: int, *, page: int = 1, page_size: int = 25,
+        status: Optional[str] = None, project_id: Optional[str] = None,
+    ) -> WebhookDeliveriesResponse:
+        _positive_id(page, "page")
+        _bounded(page_size, "page_size", 1, 100)
+        if status is not None:
+            _required_text(status, "status")
+        path = f"/org/webhooks/{_positive_id(endpoint_id, 'endpoint_id')}/deliveries"
+        params = _body(page=page, page_size=page_size, status_filter=status)
+        raw = await self._request("GET", path, params=params, project_id=project_id or _UNSET)
+        return cast(WebhookDeliveriesResponse, raw)

memorysync-1.1.0/src/memorysync/control_plane_types.py

@@ -0,0 +1,267 @@
+"""Typed request and response shapes for the bearer-authenticated control plane."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, TypedDict
+
+JsonObject = Dict[str, Any]
+
+
+class BulkRevokeResult(TypedDict):
+    key_id: int
+    status: str
+
+
+class BulkRevokeResponse(TypedDict):
+    revoked: int
+    already_revoked: int
+    not_found: int
+    results: List[BulkRevokeResult]
+
+
+class ApiKeyTestResponse(TypedDict, total=False):
+    key_id: int
+    valid: bool
+    status: str
+    environment: str
+    rate_limit_tier: str
+    scopes: List[str]
+    project_id: Optional[str]
+    last_used_at: Optional[str]
+    expires_at: Optional[str]
+    expired: bool
+    server_time: str
+
+
+class LoginTokens(TypedDict):
+    access_token: str
+    refresh_token: str
+    token_type: str
+
+
+class LoginSession(TypedDict, total=False):
+    user_id: int
+    organization_id: int
+    role: str
+
+
+class LoginResponse(TypedDict, total=False):
+    tokens: LoginTokens
+    session: LoginSession
+    mfa_required: bool
+    mfa_setup_required: bool
+
+
+class CurrentPlanResponse(TypedDict, total=False):
+    plan: JsonObject
+    status: str
+    billing_period_start: str
+    billing_period_end: str
+    payment_failed: bool
+    scheduled_plan_id: Optional[str]
+    cancel_at_period_end: bool
+
+
+class TeamMember(TypedDict, total=False):
+    id: str
+    name: str
+    email: str
+    role: str
+    status: str
+    last_active: Optional[str]
+    mfa_enabled: bool
+    auth_method: str
+    login_provider: str
+    devices: int
+    sessions: int
+    is_scim_managed: bool
+
+
+class Session(TypedDict, total=False):
+    id: int
+    is_current: bool
+    session_type: str
+    session_name: str
+    user_agent: str
+    ip: str
+    location: Optional[str]
+    geo: Optional[JsonObject]
+    created_at: str
+    last_activity_at: str
+    expires_at: str
+
+
+class SessionsResponse(TypedDict):
+    sessions: List[Session]
+    current_session_id: int
+
+
+class AuditEvent(TypedDict, total=False):
+    id: int
+    event_id: str
+    timestamp: str
+    category: str
+    actor: JsonObject
+    action: str
+    resource: JsonObject
+    severity: str
+    success: bool
+
+
+class AuditEventsResponse(TypedDict, total=False):
+    events: List[AuditEvent]
+    next_cursor: Optional[int]
+    stats: Optional[JsonObject]
+    sort: str
+
+
+class Integration(TypedDict, total=False):
+    id: str
+    name: str
+    description: str
+    category: str
+    features: List[str]
+    auth_type: str
+    is_configured: bool
+    is_connected: bool
+    coming_soon: bool
+
+
+class OrganizationMembership(TypedDict):
+    user_id: int
+    organization_id: int
+    role: str
+
+
+class OrganizationSettings(TypedDict, total=False):
+    tenant_id: str
+    tenant_name: str
+    tenant_slug: str
+    description: Optional[str]
+    plan: str
+    status: str
+    created_at: str
+    contact_email: str
+    custom_domain: Optional[str]
+    custom_domain_verified: bool
+    logo_url: Optional[str]
+    total_memories: int
+    active_users: int
+    organization_name: str
+    scheduled_deletion_at: Optional[str]
+    mfa_enrolled: bool
+    password_enabled: bool
+
+
+class Project(TypedDict, total=False):
+    id: str
+    name: str
+    tenant_id: str
+    is_default: bool
+    memory_count: int
+    archived_at: Optional[str]
+    created_at: str
+    updated_at: str
+
+
+class Webhook(TypedDict, total=False):
+    id: int
+    name: str
+    url: str
+    description: Optional[str]
+    secret_prefix: str
+    events: List[str]
+    enabled: bool
+    signature_algorithm: str
+    project_id: Optional[str]
+    secret: str
+    success_rate: float
+    updated_at: str
+
+
+class WebhooksResponse(TypedDict, total=False):
+    endpoints: List[Webhook]
+    total_endpoints: int
+    active_endpoints: int
+    total_deliveries: int
+    avg_success_rate: float
+    failing_endpoints: int
+
+
+class WebhookTestResponse(TypedDict, total=False):
+    delivery_id: int
+    event_id: str
+    event_type: str
+    endpoint_id: int
+    status: str
+    payload: JsonObject
+    message: str
+
+
+class WebhookReplayResponse(TypedDict):
+    endpoint_id: int
+    eligible: int
+    replayed: int
+    skipped: int
+    delivery_ids: List[int]
+
+
+class WebhookDelivery(TypedDict, total=False):
+    id: int
+    endpoint_id: int
+    event_type: str
+    event_id: str
+    status: str
+    payload_hash: str
+    status_code: Optional[int]
+    latency_ms: Optional[int]
+    attempt_number: int
+    max_attempts: int
+    created_at: str
+    completed_at: Optional[str]
+
+
+class WebhookDeliveriesResponse(TypedDict):
+    deliveries: List[WebhookDelivery]
+    total: int
+    page: int
+    page_size: int
+
+
+class CreateWebhookRequest(TypedDict):
+    name: str
+    url: str
+    events: List[str]
+
+
+class UpdateWebhookRequest(TypedDict, total=False):
+    name: str
+    url: str
+    description: Optional[str]
+    events: List[str]
+    retry_config: JsonObject
+    signature_config: JsonObject
+
+
+class BulkRevokeRequest(TypedDict):
+    key_ids: List[int]
+
+
+class LoginRequest(TypedDict):
+    email: str
+    password: str
+
+
+class CreateOrganizationRequest(TypedDict, total=False):
+    name: str
+    domain: str
+
+
+class TestWebhookRequest(TypedDict):
+    event_type: str
+
+
+class ReplayWebhookDeliveriesRequest(TypedDict):
+    since_minutes: int
+    statuses: List[str]
+    limit: int

memorysync-1.0.0/.gitignore

@@ -1,15 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/caches
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-/.idea/navEditor.xml
-/.idea/assetWizardSettings.xml
-.DS_Store
-/build
-/captures
-.externalNativeBuild
-.cxx
-local.properties

memorysync-1.0.0/src/memorysync/__init__.py

@@ -1,46 +0,0 @@
-"""Public package surface for the MemorySync Python SDK."""
-
-from ._version import __version__
-from .errors import (
-    AuthError,
-    MemorySyncError,
-    NotFoundError,
-    RateLimitError,
-    ServerError,
-    ValidationError,
-)
-from .types import (
-    AddSkippedResponse,
-    BulkAddItem,
-    BulkAddItemResult,
-    BulkAddResponse,
-    ComposeResponse,
-    ExportResponse,
-    Memory,
-    QueryResponse,
-    Relation,
-    RelationshipType,
-)
-from .client import AsyncMemorySyncClient, MemorySyncClient
-
-__all__ = [
-    "__version__",
-    "MemorySyncClient",
-    "AsyncMemorySyncClient",
-    "Memory",
-    "QueryResponse",
-    "BulkAddItem",
-    "BulkAddItemResult",
-    "BulkAddResponse",
-    "AddSkippedResponse",
-    "ComposeResponse",
-    "ExportResponse",
-    "Relation",
-    "RelationshipType",
-    "MemorySyncError",
-    "AuthError",
-    "ValidationError",
-    "NotFoundError",
-    "RateLimitError",
-    "ServerError",
-]

memorysync-1.0.0/src/memorysync/_version.py

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