memorysync 1.1.0__tar.gz → 1.1.1__tar.gz

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

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

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

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

memorysync-1.1.1/src/memorysync/_version.py

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

{memorysync-1.1.0 → memorysync-1.1.1}/src/memorysync/control_plane.py

@@ -60,14 +60,45 @@ def _snake_key(key: str) -> str:
     return re.sub(r"(?<!^)(?=[A-Z])", "_", key).lower()
 
 
+_OPAQUE_RESPONSE_KEYS = {"payload", "metadata", "geo", "configuration"}
+
+
 def _snake(value: Any) -> Any:
     if isinstance(value, dict):
-        return {_snake_key(str(key)): _snake(item) for key, item in value.items()}
+        normalized: Dict[str, Any] = {}
+        for key, item in value.items():
+            snake_key = _snake_key(str(key))
+            normalized[snake_key] = item if snake_key in _OPAQUE_RESPONSE_KEYS else _snake(item)
+        return normalized
     if isinstance(value, list):
         return [_snake(item) for item in value]
     return value
 
 
+def _project_override(value: Optional[str]) -> object:
+    if value is None:
+        return _UNSET
+    return cast(str, _project(value))
+
+
+def _webhook_url(value: str) -> None:
+    _required_text(value, "url")
+    parsed = urlparse(value)
+    if parsed.scheme not in ("http", "https") or not parsed.netloc:
+        raise ValidationError("url must be an absolute HTTP or HTTPS URL")
+    if parsed.username or parsed.password:
+        raise ValidationError("url must not contain credentials")
+
+
+def _string_sequence(values: Sequence[str], name: str) -> None:
+    if (
+        isinstance(values, (str, bytes))
+        or not values
+        or any(not isinstance(value, str) or not value.strip() for value in values)
+    ):
+        raise ValidationError(f"{name} must contain at least one non-empty string")
+
+
 def _detail(body: Any) -> Optional[str]:
     if not isinstance(body, dict):
         return None
@@ -156,7 +187,7 @@ class _ControlPlaneBase:
             raw: Any = response.json()
         except ValueError:
             raw = response.text or None
-        if response.status_code >= 400:
+        if not 200 <= response.status_code < 300:
             _raise_response(response, raw)
         return _snake(raw)
 
@@ -165,12 +196,8 @@ 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")
+    _webhook_url(url)
+    _string_sequence(events, "events")
 
 
 class ControlPlaneClient(_ControlPlaneBase):
@@ -218,11 +245,11 @@ class ControlPlaneClient(_ControlPlaneBase):
             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)
+        raw = self._request("POST", "/org/api-keys/bulk-revoke", json={"key_ids": ids}, project_id=_project_override(project_id))
         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)
+        raw = self._request("POST", f"/org/api-keys/{_positive_id(key_id, 'key_id')}/test", project_id=_project_override(project_id))
         return cast(ApiKeyTestResponse, raw)
 
     def login(self, email: str, password: str) -> LoginResponse:
@@ -322,14 +349,13 @@ class ControlPlaneClient(_ControlPlaneBase):
         _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))
+        return cast(Webhook, self._request("POST", "/org/webhooks", json=data, project_id=_project_override(project_id)))
 
     def list_webhooks(self, *, project_id: Optional[str] = None) -> WebhooksResponse:
-        return cast(WebhooksResponse, self._request("GET", "/org/webhooks", project_id=project_id or _UNSET))
+        return cast(WebhooksResponse, self._request("GET", "/org/webhooks", project_id=_project_override(project_id)))
 
 
     def update_webhook(
@@ -345,24 +371,22 @@ class ControlPlaneClient(_ControlPlaneBase):
             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")
+            _webhook_url(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")
+        if events is not None:
+            _string_sequence(events, "events")
         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))
+        return cast(Webhook, self._request("PATCH", path, json=data, project_id=_project_override(project_id)))
 
     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)
+        self._request("DELETE", path, project_id=_project_override(project_id))
 
     def test_webhook(
         self, endpoint_id: int, *, event_type: str = "memory.created",
@@ -370,7 +394,7 @@ class ControlPlaneClient(_ControlPlaneBase):
     ) -> 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))
+        return cast(WebhookTestResponse, self._request("POST", path, json={"event_type": event_type}, project_id=_project_override(project_id)))
 
     def replay_webhook_deliveries(
         self, endpoint_id: int, *, since_minutes: int = 60,
@@ -379,11 +403,10 @@ class ControlPlaneClient(_ControlPlaneBase):
     ) -> 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")
+        _string_sequence(statuses, "statuses")
         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))
+        return cast(WebhookReplayResponse, self._request("POST", path, json=data, project_id=_project_override(project_id)))
 
     def list_webhook_deliveries(
         self, endpoint_id: int, *, page: int = 1, page_size: int = 25,
@@ -395,7 +418,7 @@ class ControlPlaneClient(_ControlPlaneBase):
             _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))
+        return cast(WebhookDeliveriesResponse, self._request("GET", path, params=params, project_id=_project_override(project_id)))
 
 
 class AsyncControlPlaneClient(_ControlPlaneBase):
@@ -441,11 +464,11 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
             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)
+        raw = await self._request("POST", "/org/api-keys/bulk-revoke", json={"key_ids": ids}, project_id=_project_override(project_id))
         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)
+        raw = await self._request("POST", f"/org/api-keys/{_positive_id(key_id, 'key_id')}/test", project_id=_project_override(project_id))
         return cast(ApiKeyTestResponse, raw)
 
     async def login(self, email: str, password: str) -> LoginResponse:
@@ -548,15 +571,14 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
         _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)
+        raw = await self._request("POST", "/org/webhooks", json=data, project_id=_project_override(project_id))
         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))
+        return cast(WebhooksResponse, await self._request("GET", "/org/webhooks", project_id=_project_override(project_id)))
 
 
     async def update_webhook(
@@ -572,25 +594,23 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
             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")
+            _webhook_url(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")
+        if events is not None:
+            _string_sequence(events, "events")
         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)
+        raw = await self._request("PATCH", path, json=data, project_id=_project_override(project_id))
         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)
+        await self._request("DELETE", path, project_id=_project_override(project_id))
 
     async def test_webhook(
         self, endpoint_id: int, *, event_type: str = "memory.created",
@@ -598,7 +618,7 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
     ) -> 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)
+        raw = await self._request("POST", path, json={"event_type": event_type}, project_id=_project_override(project_id))
         return cast(WebhookTestResponse, raw)
 
     async def replay_webhook_deliveries(
@@ -608,11 +628,10 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
     ) -> 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")
+        _string_sequence(statuses, "statuses")
         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)
+        raw = await self._request("POST", path, json=data, project_id=_project_override(project_id))
         return cast(WebhookReplayResponse, raw)
 
     async def list_webhook_deliveries(
@@ -625,5 +644,5 @@ class AsyncControlPlaneClient(_ControlPlaneBase):
             _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)
+        raw = await self._request("GET", path, params=params, project_id=_project_override(project_id))
         return cast(WebhookDeliveriesResponse, raw)

memorysync-1.1.0/src/memorysync/_version.py

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