loomal-sdk 0.1.0__tar.gz

loomal_sdk-0.1.0/LICENSE

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

loomal_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: loomal-sdk
+Version: 0.1.0
+Summary: Official Python SDK for the Loomal API — identity infrastructure for AI agents
+Author: Loomal
+License: MIT
+Project-URL: Homepage, https://loomal.ai
+Project-URL: Documentation, https://docs.loomal.ai
+Project-URL: Repository, https://github.com/loomal-ai/loomal-python
+Project-URL: Issues, https://github.com/loomal-ai/loomal-python/issues
+Keywords: loomal,ai,agent,email,mcp,did,vault,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# Loomal Python SDK
+
+The official Python SDK for the [Loomal API](https://loomal.ai) -- identity infrastructure for AI agents.
+
+[![PyPI version](https://img.shields.io/pypi/v/loomal-sdk.svg)](https://pypi.org/project/loomal-sdk/)
+[![Python 3.9+](https://img.shields.io/pypi/pyversions/loomal-sdk.svg)](https://pypi.org/project/loomal-sdk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install loomal-sdk
+```
+
+> The distribution is `loomal-sdk` on PyPI, but the import name is `loomal`.
+
+## Quick start
+
+```python
+from loomal import Loomal
+
+client = Loomal(api_key="loid-...")
+
+me = client.identity.whoami()
+print(me.email)
+
+client.mail.send(
+    to=["colleague@example.com"],
+    subject="Hello from my agent",
+    text="Sent via the Loomal Python SDK.",
+)
+```
+
+## Async usage
+
+```python
+from loomal import AsyncLoomal
+
+async with AsyncLoomal(api_key="loid-...") as client:
+    me = await client.identity.whoami()
+    await client.mail.send(
+        to=["colleague@example.com"],
+        subject="Hello",
+        text="Sent asynchronously.",
+    )
+```
+
+## Authentication
+
+Pass your API key directly, or set the `LOOMAL_API_KEY` environment variable:
+
+```python
+# Explicit
+client = Loomal(api_key="loid-...")
+
+# From environment
+import os
+os.environ["LOOMAL_API_KEY"] = "loid-..."
+client = Loomal()
+```
+
+Both `Loomal` and `AsyncLoomal` support context managers for automatic resource cleanup:
+
+```python
+with Loomal() as client:
+    me = client.identity.whoami()
+```
+
+## Usage
+
+### Identity
+
+```python
+me = client.identity.whoami()
+print(me.email, me.display_name)
+```
+
+### More resources
+
+The SDK also exposes `client.mail`, `client.calendar`, `client.vault`, `client.logs`, and `client.did`. See the full reference at **[docs.loomal.ai](https://docs.loomal.ai)** for request/response shapes, pagination, and end-to-end examples.
+
+## Error handling
+
+All API errors raise `LoomalError` with structured fields:
+
+```python
+from loomal import LoomalError
+
+try:
+    client.mail.send(to=["a@b.com"], subject="Hi", text="Hello")
+except LoomalError as e:
+    print(e.status)   # HTTP status code
+    print(e.code)     # Error code string
+    print(e.message)  # Human-readable message
+```
+
+## Types
+
+The SDK returns typed dataclasses, not raw dictionaries. API responses are automatically converted from camelCase to snake_case.
+
+| Type | Description |
+|------|-------------|
+| `IdentityResponse` | Agent identity details |
+| `MessageResponse` | Email message |
+| `ThreadResponse` | Thread summary |
+| `ThreadDetailResponse` | Thread with messages |
+| `CredentialMetadata` | Vault credential metadata |
+| `CredentialWithData` | Credential with decrypted data |
+| `ActivityLog` | Single activity log entry |
+| `LogsStats` | Aggregated log statistics |
+| `TotpResponse` | Generated TOTP code |
+| `DidDocument` | DID document |
+
+> **Note:** The `from` field in message responses is exposed as `from_addrs` since `from` is a reserved keyword in Python.
+
+## Requirements
+
+- Python 3.9+
+- [`httpx`](https://www.python-httpx.org/) (installed automatically)
+
+## Links
+
+- [Documentation](https://docs.loomal.ai)
+- [Console](https://console.loomal.ai)
+- [Website](https://loomal.ai)
+- [PyPI](https://pypi.org/project/loomal-sdk/)
+
+## License
+
+MIT

loomal_sdk-0.1.0/README.md

@@ -0,0 +1,130 @@
+# Loomal Python SDK
+
+The official Python SDK for the [Loomal API](https://loomal.ai) -- identity infrastructure for AI agents.
+
+[![PyPI version](https://img.shields.io/pypi/v/loomal-sdk.svg)](https://pypi.org/project/loomal-sdk/)
+[![Python 3.9+](https://img.shields.io/pypi/pyversions/loomal-sdk.svg)](https://pypi.org/project/loomal-sdk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Installation
+
+```bash
+pip install loomal-sdk
+```
+
+> The distribution is `loomal-sdk` on PyPI, but the import name is `loomal`.
+
+## Quick start
+
+```python
+from loomal import Loomal
+
+client = Loomal(api_key="loid-...")
+
+me = client.identity.whoami()
+print(me.email)
+
+client.mail.send(
+    to=["colleague@example.com"],
+    subject="Hello from my agent",
+    text="Sent via the Loomal Python SDK.",
+)
+```
+
+## Async usage
+
+```python
+from loomal import AsyncLoomal
+
+async with AsyncLoomal(api_key="loid-...") as client:
+    me = await client.identity.whoami()
+    await client.mail.send(
+        to=["colleague@example.com"],
+        subject="Hello",
+        text="Sent asynchronously.",
+    )
+```
+
+## Authentication
+
+Pass your API key directly, or set the `LOOMAL_API_KEY` environment variable:
+
+```python
+# Explicit
+client = Loomal(api_key="loid-...")
+
+# From environment
+import os
+os.environ["LOOMAL_API_KEY"] = "loid-..."
+client = Loomal()
+```
+
+Both `Loomal` and `AsyncLoomal` support context managers for automatic resource cleanup:
+
+```python
+with Loomal() as client:
+    me = client.identity.whoami()
+```
+
+## Usage
+
+### Identity
+
+```python
+me = client.identity.whoami()
+print(me.email, me.display_name)
+```
+
+### More resources
+
+The SDK also exposes `client.mail`, `client.calendar`, `client.vault`, `client.logs`, and `client.did`. See the full reference at **[docs.loomal.ai](https://docs.loomal.ai)** for request/response shapes, pagination, and end-to-end examples.
+
+## Error handling
+
+All API errors raise `LoomalError` with structured fields:
+
+```python
+from loomal import LoomalError
+
+try:
+    client.mail.send(to=["a@b.com"], subject="Hi", text="Hello")
+except LoomalError as e:
+    print(e.status)   # HTTP status code
+    print(e.code)     # Error code string
+    print(e.message)  # Human-readable message
+```
+
+## Types
+
+The SDK returns typed dataclasses, not raw dictionaries. API responses are automatically converted from camelCase to snake_case.
+
+| Type | Description |
+|------|-------------|
+| `IdentityResponse` | Agent identity details |
+| `MessageResponse` | Email message |
+| `ThreadResponse` | Thread summary |
+| `ThreadDetailResponse` | Thread with messages |
+| `CredentialMetadata` | Vault credential metadata |
+| `CredentialWithData` | Credential with decrypted data |
+| `ActivityLog` | Single activity log entry |
+| `LogsStats` | Aggregated log statistics |
+| `TotpResponse` | Generated TOTP code |
+| `DidDocument` | DID document |
+
+> **Note:** The `from` field in message responses is exposed as `from_addrs` since `from` is a reserved keyword in Python.
+
+## Requirements
+
+- Python 3.9+
+- [`httpx`](https://www.python-httpx.org/) (installed automatically)
+
+## Links
+
+- [Documentation](https://docs.loomal.ai)
+- [Console](https://console.loomal.ai)
+- [Website](https://loomal.ai)
+- [PyPI](https://pypi.org/project/loomal-sdk/)
+
+## License
+
+MIT

loomal_sdk-0.1.0/loomal/__init__.py

@@ -0,0 +1,23 @@
+from loomal.client import Loomal, AsyncLoomal
+from loomal.platform_client import LoomalPlatform, AsyncLoomalPlatform
+from loomal.types import (
+    MessageResponse, ThreadResponse, ThreadDetailResponse,
+    CredentialMetadata, CredentialWithData, IdentityResponse,
+    IdentitySummary, IdentityDetail, CreateIdentityResponse, RotateKeyResponse,
+    CalendarEvent,
+    ActivityLog, LogsStats, TotpResponse, DidDocument,
+)
+from loomal._errors import LoomalError
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Loomal", "AsyncLoomal",
+    "LoomalPlatform", "AsyncLoomalPlatform",
+    "LoomalError",
+    "MessageResponse", "ThreadResponse", "ThreadDetailResponse",
+    "CredentialMetadata", "CredentialWithData", "IdentityResponse",
+    "IdentitySummary", "IdentityDetail", "CreateIdentityResponse", "RotateKeyResponse",
+    "CalendarEvent",
+    "ActivityLog", "LogsStats", "TotpResponse", "DidDocument",
+]

loomal_sdk-0.1.0/loomal/_errors.py

@@ -0,0 +1,10 @@
+class LoomalError(Exception):
+    """Raised when the Loomal API returns a non-2xx response."""
+
+    def __init__(self, status: int, code: str, message: str) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+
+    def __repr__(self) -> str:
+        return f"LoomalError(status={self.status}, code={self.code!r}, message={self.args[0]!r})"

loomal_sdk-0.1.0/loomal/_http.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+
+from loomal._errors import LoomalError
+
+DEFAULT_BASE_URL = "https://api.loomal.ai"
+DEFAULT_TIMEOUT = 30.0
+
+
+def _build_headers(api_key: str) -> dict[str, str]:
+    return {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+
+def _handle_response(response: httpx.Response) -> Any:
+    if response.status_code == 204:
+        return None
+
+    data = response.json() if response.content else {}
+
+    if not response.is_success:
+        raise LoomalError(
+            status=response.status_code,
+            code=data.get("error", "unknown_error"),
+            message=data.get("message", f"Request failed with status {response.status_code}"),
+        )
+
+    return data
+
+
+class SyncHttpClient:
+    def __init__(self, base_url: str, api_key: str, timeout: float = DEFAULT_TIMEOUT) -> None:
+        self._client = httpx.Client(
+            base_url=base_url.rstrip("/"),
+            headers=_build_headers(api_key),
+            timeout=timeout,
+        )
+
+    def get(self, path: str, params: Optional[dict[str, Any]] = None) -> Any:
+        return _handle_response(self._client.get(path, params=params))
+
+    def post(self, path: str, json: Optional[dict[str, Any]] = None) -> Any:
+        return _handle_response(self._client.post(path, json=json))
+
+    def put(self, path: str, json: Optional[dict[str, Any]] = None) -> Any:
+        return _handle_response(self._client.put(path, json=json))
+
+    def patch(self, path: str, json: Optional[dict[str, Any]] = None) -> Any:
+        return _handle_response(self._client.patch(path, json=json))
+
+    def delete(self, path: str) -> Any:
+        return _handle_response(self._client.delete(path))
+
+    def close(self) -> None:
+        self._client.close()
+
+
+class AsyncHttpClient:
+    def __init__(self, base_url: str, api_key: str, timeout: float = DEFAULT_TIMEOUT) -> None:
+        self._client = httpx.AsyncClient(
+            base_url=base_url.rstrip("/"),
+            headers=_build_headers(api_key),
+            timeout=timeout,
+        )
+
+    async def get(self, path: str, params: Optional[dict[str, Any]] = None) -> Any:
+        return _handle_response(await self._client.get(path, params=params))
+
+    async def post(self, path: str, json: Optional[dict[str, Any]] = None) -> Any:
+        return _handle_response(await self._client.post(path, json=json))
+
+    async def put(self, path: str, json: Optional[dict[str, Any]] = None) -> Any:
+        return _handle_response(await self._client.put(path, json=json))
+
+    async def patch(self, path: str, json: Optional[dict[str, Any]] = None) -> Any:
+        return _handle_response(await self._client.patch(path, json=json))
+
+    async def delete(self, path: str) -> Any:
+        return _handle_response(await self._client.delete(path))
+
+    async def close(self) -> None:
+        await self._client.aclose()

loomal_sdk-0.1.0/loomal/client.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+from loomal._http import SyncHttpClient, AsyncHttpClient, DEFAULT_BASE_URL
+from loomal.resources.identity import IdentityResource, AsyncIdentityResource
+from loomal.resources.mail import MailResource, AsyncMailResource
+from loomal.resources.vault import VaultResource, AsyncVaultResource
+from loomal.resources.logs import LogsResource, AsyncLogsResource
+from loomal.resources.did import DidResource, AsyncDidResource
+from loomal.resources.calendar import CalendarResource, AsyncCalendarResource
+
+
+class Loomal:
+    """Synchronous Loomal API client."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                 timeout: float = 30.0) -> None:
+        resolved_key = api_key or os.environ.get("LOOMAL_API_KEY")
+        if not resolved_key:
+            raise ValueError("API key is required. Pass api_key= or set LOOMAL_API_KEY env var.")
+
+        http = SyncHttpClient(
+            base_url=base_url or os.environ.get("LOOMAL_API_URL", DEFAULT_BASE_URL),
+            api_key=resolved_key, timeout=timeout,
+        )
+        self.identity = IdentityResource(http)
+        self.mail = MailResource(http)
+        self.vault = VaultResource(http)
+        self.logs = LogsResource(http)
+        self.did = DidResource(http)
+        self.calendar = CalendarResource(http)
+        self._http = http
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class AsyncLoomal:
+    """Asynchronous Loomal API client."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                 timeout: float = 30.0) -> None:
+        resolved_key = api_key or os.environ.get("LOOMAL_API_KEY")
+        if not resolved_key:
+            raise ValueError("API key is required. Pass api_key= or set LOOMAL_API_KEY env var.")
+
+        http = AsyncHttpClient(
+            base_url=base_url or os.environ.get("LOOMAL_API_URL", DEFAULT_BASE_URL),
+            api_key=resolved_key, timeout=timeout,
+        )
+        self.identity = AsyncIdentityResource(http)
+        self.mail = AsyncMailResource(http)
+        self.vault = AsyncVaultResource(http)
+        self.logs = AsyncLogsResource(http)
+        self.did = AsyncDidResource(http)
+        self.calendar = AsyncCalendarResource(http)
+        self._http = http
+
+    async def close(self) -> None:
+        await self._http.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.close()

loomal_sdk-0.1.0/loomal/platform_client.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+from loomal._http import SyncHttpClient, AsyncHttpClient, DEFAULT_BASE_URL
+from loomal.resources.platform_identities import PlatformIdentitiesResource, AsyncPlatformIdentitiesResource
+
+
+class LoomalPlatform:
+    """Synchronous Loomal Platform client for identity management."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                 timeout: float = 30.0) -> None:
+        resolved_key = api_key or os.environ.get("LOOMAL_PLATFORM_KEY")
+        if not resolved_key:
+            raise ValueError("Platform key is required. Pass api_key= or set LOOMAL_PLATFORM_KEY env var.")
+
+        http = SyncHttpClient(
+            base_url=base_url or os.environ.get("LOOMAL_API_URL", DEFAULT_BASE_URL),
+            api_key=resolved_key, timeout=timeout,
+        )
+        self.identities = PlatformIdentitiesResource(http)
+        self._http = http
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class AsyncLoomalPlatform:
+    """Asynchronous Loomal Platform client for identity management."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                 timeout: float = 30.0) -> None:
+        resolved_key = api_key or os.environ.get("LOOMAL_PLATFORM_KEY")
+        if not resolved_key:
+            raise ValueError("Platform key is required. Pass api_key= or set LOOMAL_PLATFORM_KEY env var.")
+
+        http = AsyncHttpClient(
+            base_url=base_url or os.environ.get("LOOMAL_API_URL", DEFAULT_BASE_URL),
+            api_key=resolved_key, timeout=timeout,
+        )
+        self.identities = AsyncPlatformIdentitiesResource(http)
+        self._http = http
+
+    async def close(self) -> None:
+        await self._http.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.close()

loomal_sdk-0.1.0/loomal/resources/calendar.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+from typing import Any, Optional
+from loomal.types import CalendarEvent
+
+
+class CalendarResource:
+    def __init__(self, http):
+        self._http = http
+
+    def create(self, title: str, start_at: str, end_at: Optional[str] = None,
+               is_all_day: bool = False, description: Optional[str] = None,
+               location: Optional[str] = None, metadata: Optional[dict[str, Any]] = None) -> CalendarEvent:
+        body: dict[str, Any] = {"title": title, "startAt": start_at, "isAllDay": is_all_day}
+        if end_at: body["endAt"] = end_at
+        if description: body["description"] = description
+        if location: body["location"] = location
+        if metadata: body["metadata"] = metadata
+        return CalendarEvent.from_dict(self._http.post("/v0/calendar", json=body))
+
+    def list(self, limit: Optional[int] = None, from_date: Optional[str] = None,
+             to_date: Optional[str] = None) -> dict[str, Any]:
+        params: dict[str, Any] = {}
+        if limit is not None: params["limit"] = limit
+        if from_date: params["from"] = from_date
+        if to_date: params["to"] = to_date
+        data = self._http.get("/v0/calendar", params=params or None)
+        return {"events": [CalendarEvent.from_dict(e) for e in data.get("events", [])], "count": data["count"]}
+
+    def get(self, event_id: str) -> CalendarEvent:
+        return CalendarEvent.from_dict(self._http.get(f"/v0/calendar/{event_id}"))
+
+    def update(self, event_id: str, title: Optional[str] = None, start_at: Optional[str] = None,
+               end_at: Optional[str] = None, is_all_day: Optional[bool] = None,
+               description: Optional[str] = None, location: Optional[str] = None) -> CalendarEvent:
+        body: dict[str, Any] = {}
+        if title is not None: body["title"] = title
+        if start_at is not None: body["startAt"] = start_at
+        if end_at is not None: body["endAt"] = end_at
+        if is_all_day is not None: body["isAllDay"] = is_all_day
+        if description is not None: body["description"] = description
+        if location is not None: body["location"] = location
+        return CalendarEvent.from_dict(self._http.patch(f"/v0/calendar/{event_id}", json=body))
+
+    def delete(self, event_id: str) -> None:
+        self._http.delete(f"/v0/calendar/{event_id}")
+
+    def set_public(self, enabled: bool) -> dict[str, bool]:
+        return self._http.post("/v0/calendar/public", json={"enabled": enabled})
+
+
+class AsyncCalendarResource:
+    def __init__(self, http):
+        self._http = http
+
+    async def create(self, title: str, start_at: str, end_at: Optional[str] = None,
+                     is_all_day: bool = False, description: Optional[str] = None,
+                     location: Optional[str] = None, metadata: Optional[dict[str, Any]] = None) -> CalendarEvent:
+        body: dict[str, Any] = {"title": title, "startAt": start_at, "isAllDay": is_all_day}
+        if end_at: body["endAt"] = end_at
+        if description: body["description"] = description
+        if location: body["location"] = location
+        if metadata: body["metadata"] = metadata
+        return CalendarEvent.from_dict(await self._http.post("/v0/calendar", json=body))
+
+    async def list(self, limit: Optional[int] = None, from_date: Optional[str] = None,
+                   to_date: Optional[str] = None) -> dict[str, Any]:
+        params: dict[str, Any] = {}
+        if limit is not None: params["limit"] = limit
+        if from_date: params["from"] = from_date
+        if to_date: params["to"] = to_date
+        data = await self._http.get("/v0/calendar", params=params or None)
+        return {"events": [CalendarEvent.from_dict(e) for e in data.get("events", [])], "count": data["count"]}
+
+    async def get(self, event_id: str) -> CalendarEvent:
+        return CalendarEvent.from_dict(await self._http.get(f"/v0/calendar/{event_id}"))
+
+    async def update(self, event_id: str, title: Optional[str] = None, start_at: Optional[str] = None,
+                     end_at: Optional[str] = None, is_all_day: Optional[bool] = None,
+                     description: Optional[str] = None, location: Optional[str] = None) -> CalendarEvent:
+        body: dict[str, Any] = {}
+        if title is not None: body["title"] = title
+        if start_at is not None: body["startAt"] = start_at
+        if end_at is not None: body["endAt"] = end_at
+        if is_all_day is not None: body["isAllDay"] = is_all_day
+        if description is not None: body["description"] = description
+        if location is not None: body["location"] = location
+        return CalendarEvent.from_dict(await self._http.patch(f"/v0/calendar/{event_id}", json=body))
+
+    async def delete(self, event_id: str) -> None:
+        await self._http.delete(f"/v0/calendar/{event_id}")
+
+    async def set_public(self, enabled: bool) -> dict[str, bool]:
+        return await self._http.post("/v0/calendar/public", json={"enabled": enabled})