leash-sdk 0.1.0__tar.gz

leash_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: leash-sdk
+Version: 0.1.0
+Summary: Leash platform SDK - access Gmail, Calendar, Drive and more from deployed apps
+License: MIT
+Project-URL: Homepage, https://leash.build
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Dynamic: requires-python
+
+# Leash SDK (Python)
+
+Python SDK for accessing platform integrations (Gmail, Google Calendar, Google Drive) from apps deployed on [Leash](https://leash.build).
+
+## Install
+
+```bash
+pip install leash-sdk
+```
+
+## Usage
+
+```python
+from leash import LeashIntegrations
+
+# Get the auth token from the leash-auth cookie (e.g. in Flask/Django)
+integrations = LeashIntegrations(auth_token="your-jwt-token")
+
+# Gmail
+emails = integrations.gmail.list_messages(max_results=10)
+integrations.gmail.send_message(to="user@example.com", subject="Hello", body="World")
+
+# Calendar
+events = integrations.calendar.list_events(time_min="2026-04-01T00:00:00Z")
+integrations.calendar.create_event(
+    summary="Meeting",
+    start="2026-04-10T10:00:00Z",
+    end="2026-04-10T11:00:00Z",
+)
+
+# Drive
+files = integrations.drive.list_files(max_results=10)
+integrations.drive.upload_file(name="notes.txt", content="hello", mime_type="text/plain")
+```
+
+## How it works
+
+The SDK calls the Leash platform proxy at `https://api.leash.build/api/integrations/{provider}/{action}`. The platform handles all OAuth token management -- the SDK just passes the user's auth token and makes typed API calls.

leash_sdk-0.1.0/README.md

@@ -0,0 +1,38 @@
+# Leash SDK (Python)
+
+Python SDK for accessing platform integrations (Gmail, Google Calendar, Google Drive) from apps deployed on [Leash](https://leash.build).
+
+## Install
+
+```bash
+pip install leash-sdk
+```
+
+## Usage
+
+```python
+from leash import LeashIntegrations
+
+# Get the auth token from the leash-auth cookie (e.g. in Flask/Django)
+integrations = LeashIntegrations(auth_token="your-jwt-token")
+
+# Gmail
+emails = integrations.gmail.list_messages(max_results=10)
+integrations.gmail.send_message(to="user@example.com", subject="Hello", body="World")
+
+# Calendar
+events = integrations.calendar.list_events(time_min="2026-04-01T00:00:00Z")
+integrations.calendar.create_event(
+    summary="Meeting",
+    start="2026-04-10T10:00:00Z",
+    end="2026-04-10T11:00:00Z",
+)
+
+# Drive
+files = integrations.drive.list_files(max_results=10)
+integrations.drive.upload_file(name="notes.txt", content="hello", mime_type="text/plain")
+```
+
+## How it works
+
+The SDK calls the Leash platform proxy at `https://api.leash.build/api/integrations/{provider}/{action}`. The platform handles all OAuth token management -- the SDK just passes the user's auth token and makes typed API calls.

leash_sdk-0.1.0/leash/__init__.py

@@ -0,0 +1,7 @@
+"""Leash SDK - access Gmail, Calendar, Drive and more via the Leash platform."""
+
+from leash.client import LeashIntegrations
+from leash.types import LeashError
+
+__all__ = ["LeashIntegrations", "LeashError"]
+__version__ = "0.1.0"

leash_sdk-0.1.0/leash/calendar.py

@@ -0,0 +1,88 @@
+"""Google Calendar integration client."""
+
+from typing import Any, Dict, Optional
+
+from leash.types import CallFn
+
+
+class CalendarClient:
+    """Client for Google Calendar operations via the Leash platform proxy."""
+
+    def __init__(self, call: CallFn):
+        self._call = call
+
+    def list_calendars(self) -> Dict[str, Any]:
+        """List all calendars accessible to the user.
+
+        Returns:
+            Dict with calendar list data.
+        """
+        return self._call("google_calendar", "list-calendars", {})
+
+    def list_events(
+        self,
+        calendar_id: str = "primary",
+        time_min: Optional[str] = None,
+        time_max: Optional[str] = None,
+        max_results: int = 10,
+    ) -> Dict[str, Any]:
+        """List events on a calendar.
+
+        Args:
+            calendar_id: Calendar identifier (default 'primary').
+            time_min: Lower bound for event start time (RFC 3339, e.g. '2026-04-01T00:00:00Z').
+            time_max: Upper bound for event start time (RFC 3339).
+            max_results: Maximum number of events to return.
+
+        Returns:
+            Dict with 'items' list of events.
+        """
+        params: Dict[str, Any] = {"calendarId": calendar_id, "maxResults": max_results}
+        if time_min:
+            params["timeMin"] = time_min
+        if time_max:
+            params["timeMax"] = time_max
+        return self._call("google_calendar", "list-events", params)
+
+    def get_event(self, calendar_id: str, event_id: str) -> Dict[str, Any]:
+        """Get a single event by ID.
+
+        Args:
+            calendar_id: Calendar identifier.
+            event_id: Event identifier.
+
+        Returns:
+            The event object.
+        """
+        return self._call("google_calendar", "get-event", {"calendarId": calendar_id, "eventId": event_id})
+
+    def create_event(
+        self,
+        calendar_id: str = "primary",
+        summary: Optional[str] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a new calendar event.
+
+        Args:
+            calendar_id: Calendar identifier (default 'primary').
+            summary: Event title.
+            start: Start time (RFC 3339, e.g. '2026-04-10T10:00:00Z').
+            end: End time (RFC 3339).
+            description: Event description.
+
+        Returns:
+            The created event object.
+        """
+        params: Dict[str, Any] = {"calendarId": calendar_id}
+        if summary:
+            params["summary"] = summary
+        if start:
+            params["start"] = start
+        if end:
+            params["end"] = end
+        if description:
+            params["description"] = description
+        return self._call("google_calendar", "create-event", params)

leash_sdk-0.1.0/leash/client.py

@@ -0,0 +1,122 @@
+"""Main LeashIntegrations client."""
+
+from typing import Any, Dict, Optional
+
+import requests
+
+from leash.calendar import CalendarClient
+from leash.drive import DriveClient
+from leash.gmail import GmailClient
+from leash.types import LeashError
+
+DEFAULT_PLATFORM_URL = "https://api.leash.build"
+
+
+class LeashIntegrations:
+    """Client for accessing Leash platform integrations.
+
+    Args:
+        auth_token: The leash-auth JWT token (from cookie or env).
+        platform_url: Base URL of the Leash platform API.
+            Defaults to https://api.leash.build.
+    """
+
+    def __init__(self, auth_token: str, platform_url: str = DEFAULT_PLATFORM_URL):
+        self.auth_token = auth_token
+        self.platform_url = platform_url.rstrip("/")
+
+    @property
+    def gmail(self) -> GmailClient:
+        """Gmail integration client."""
+        return GmailClient(self._call)
+
+    @property
+    def calendar(self) -> CalendarClient:
+        """Google Calendar integration client."""
+        return CalendarClient(self._call)
+
+    @property
+    def drive(self) -> DriveClient:
+        """Google Drive integration client."""
+        return DriveClient(self._call)
+
+    def _call(self, provider: str, action: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Call the platform proxy.
+
+        Args:
+            provider: Integration provider name (e.g. 'gmail').
+            action: Action to perform (e.g. 'list-messages').
+            params: Optional request body parameters.
+
+        Returns:
+            The ``data`` field from the platform response.
+
+        Raises:
+            LeashError: If the platform returns a non-success response.
+        """
+        response = requests.post(
+            f"{self.platform_url}/api/integrations/{provider}/{action}",
+            json=params or {},
+            headers={
+                "Authorization": f"Bearer {self.auth_token}",
+                "Content-Type": "application/json",
+            },
+        )
+        data = response.json()
+        if not data.get("success"):
+            raise LeashError(
+                message=data.get("error", "Unknown error"),
+                code=data.get("code"),
+                connect_url=data.get("connectUrl"),
+            )
+        return data.get("data")
+
+    def is_connected(self, provider_id: str) -> bool:
+        """Check if a provider is connected for the current user.
+
+        Args:
+            provider_id: The provider identifier (e.g. 'gmail').
+
+        Returns:
+            True if the provider is actively connected, False otherwise.
+        """
+        try:
+            connections = self.get_connections()
+            conn = next((c for c in connections if c.get("providerId") == provider_id), None)
+            return conn is not None and conn.get("status") == "active"
+        except Exception:
+            return False
+
+    def get_connections(self) -> list:
+        """Get connection status for all providers.
+
+        Returns:
+            A list of connection status dicts.
+        """
+        response = requests.get(
+            f"{self.platform_url}/api/integrations/connections",
+            headers={"Authorization": f"Bearer {self.auth_token}"},
+        )
+        data = response.json()
+        if not data.get("success"):
+            raise LeashError(
+                message=data.get("error", "Unknown error"),
+                code=data.get("code"),
+            )
+        return data.get("data", [])
+
+    def get_connect_url(self, provider_id: str, return_url: Optional[str] = None) -> str:
+        """Get the URL to connect a provider (for UI buttons).
+
+        Args:
+            provider_id: The provider identifier.
+            return_url: Optional URL to redirect back to after connecting.
+
+        Returns:
+            The full URL to initiate the OAuth connection flow.
+        """
+        url = f"{self.platform_url}/api/integrations/connect/{provider_id}"
+        if return_url:
+            from urllib.parse import quote
+            url += f"?return_url={quote(return_url)}"
+        return url

leash_sdk-0.1.0/leash/drive.py

@@ -0,0 +1,118 @@
+"""Google Drive integration client."""
+
+from typing import Any, Dict, Optional
+
+from leash.types import CallFn
+
+
+class DriveClient:
+    """Client for Google Drive operations via the Leash platform proxy."""
+
+    def __init__(self, call: CallFn):
+        self._call = call
+
+    def list_files(
+        self,
+        query: Optional[str] = None,
+        max_results: int = 20,
+        folder_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """List files in the user's Drive.
+
+        Args:
+            query: Drive search query (Google Drive API query syntax).
+            max_results: Maximum number of files to return.
+            folder_id: Restrict to files within a specific folder.
+
+        Returns:
+            Dict with 'files' list.
+        """
+        params: Dict[str, Any] = {"maxResults": max_results}
+        if query:
+            params["query"] = query
+        if folder_id:
+            params["folderId"] = folder_id
+        return self._call("google_drive", "list-files", params)
+
+    def get_file(self, file_id: str) -> Dict[str, Any]:
+        """Get file metadata by ID.
+
+        Args:
+            file_id: The file identifier.
+
+        Returns:
+            The file metadata object.
+        """
+        return self._call("google_drive", "get-file", {"fileId": file_id})
+
+    def download_file(self, file_id: str) -> Any:
+        """Download file content by ID.
+
+        Args:
+            file_id: The file identifier.
+
+        Returns:
+            The file content (format depends on file type).
+        """
+        return self._call("google_drive", "download-file", {"fileId": file_id})
+
+    def create_folder(self, name: str, parent_id: Optional[str] = None) -> Dict[str, Any]:
+        """Create a new folder.
+
+        Args:
+            name: Folder name.
+            parent_id: Optional parent folder ID.
+
+        Returns:
+            The created folder metadata.
+        """
+        params: Dict[str, Any] = {"name": name}
+        if parent_id:
+            params["parentId"] = parent_id
+        return self._call("google_drive", "create-folder", params)
+
+    def upload_file(
+        self,
+        name: str,
+        content: str,
+        mime_type: str,
+        parent_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Upload a file to Drive.
+
+        Args:
+            name: File name.
+            content: File content (text or base64-encoded).
+            mime_type: MIME type of the file (e.g. 'text/plain').
+            parent_id: Optional parent folder ID.
+
+        Returns:
+            The created file metadata.
+        """
+        params: Dict[str, Any] = {"name": name, "content": content, "mimeType": mime_type}
+        if parent_id:
+            params["parentId"] = parent_id
+        return self._call("google_drive", "upload-file", params)
+
+    def delete_file(self, file_id: str) -> Dict[str, Any]:
+        """Delete a file by ID.
+
+        Args:
+            file_id: The file identifier.
+
+        Returns:
+            Confirmation of deletion.
+        """
+        return self._call("google_drive", "delete-file", {"fileId": file_id})
+
+    def search_files(self, query: str, max_results: int = 20) -> Dict[str, Any]:
+        """Search files using a query string.
+
+        Args:
+            query: Search query (Google Drive API query syntax).
+            max_results: Maximum number of results.
+
+        Returns:
+            Dict with 'files' list.
+        """
+        return self._call("google_drive", "search-files", {"query": query, "maxResults": max_results})

leash_sdk-0.1.0/leash/gmail.py

@@ -0,0 +1,98 @@
+"""Gmail integration client."""
+
+from typing import Any, Dict, List, Optional
+
+from leash.types import CallFn
+
+
+class GmailClient:
+    """Client for Gmail operations via the Leash platform proxy."""
+
+    def __init__(self, call: CallFn):
+        self._call = call
+
+    def list_messages(
+        self,
+        query: Optional[str] = None,
+        max_results: int = 20,
+        label_ids: Optional[List[str]] = None,
+        page_token: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """List messages in the user's mailbox.
+
+        Args:
+            query: Gmail search query (e.g. 'from:user@example.com').
+            max_results: Maximum number of messages to return.
+            label_ids: Filter by label IDs (e.g. ['INBOX']).
+            page_token: Token for fetching the next page of results.
+
+        Returns:
+            Dict with 'messages', 'nextPageToken', and 'resultSizeEstimate'.
+        """
+        params: Dict[str, Any] = {"maxResults": max_results}
+        if query:
+            params["query"] = query
+        if label_ids:
+            params["labelIds"] = label_ids
+        if page_token:
+            params["pageToken"] = page_token
+        return self._call("gmail", "list-messages", params)
+
+    def get_message(self, message_id: str, format: str = "full") -> Dict[str, Any]:
+        """Get a single message by ID.
+
+        Args:
+            message_id: The message ID.
+            format: Response format ('full', 'metadata', 'minimal', 'raw').
+
+        Returns:
+            The full message object.
+        """
+        return self._call("gmail", "get-message", {"messageId": message_id, "format": format})
+
+    def send_message(
+        self,
+        to: str,
+        subject: str,
+        body: str,
+        cc: Optional[str] = None,
+        bcc: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Send an email message.
+
+        Args:
+            to: Recipient email address.
+            subject: Email subject line.
+            body: Email body text.
+            cc: CC recipient(s).
+            bcc: BCC recipient(s).
+
+        Returns:
+            The sent message metadata.
+        """
+        params: Dict[str, Any] = {"to": to, "subject": subject, "body": body}
+        if cc:
+            params["cc"] = cc
+        if bcc:
+            params["bcc"] = bcc
+        return self._call("gmail", "send-message", params)
+
+    def search_messages(self, query: str, max_results: int = 20) -> Dict[str, Any]:
+        """Search messages using a Gmail query string.
+
+        Args:
+            query: Gmail search query.
+            max_results: Maximum number of results to return.
+
+        Returns:
+            Dict with 'messages', 'nextPageToken', and 'resultSizeEstimate'.
+        """
+        return self._call("gmail", "search-messages", {"query": query, "maxResults": max_results})
+
+    def list_labels(self) -> Dict[str, Any]:
+        """List all labels in the user's mailbox.
+
+        Returns:
+            Dict with 'labels' list.
+        """
+        return self._call("gmail", "list-labels", {})

leash_sdk-0.1.0/leash/types.py

@@ -0,0 +1,16 @@
+"""Shared types for the Leash SDK."""
+
+from typing import Any, Callable, Dict, Optional
+
+
+class LeashError(Exception):
+    """Raised when a Leash platform API call fails."""
+
+    def __init__(self, message: str, code: Optional[str] = None, connect_url: Optional[str] = None):
+        super().__init__(message)
+        self.code = code
+        self.connect_url = connect_url
+
+
+# Type alias for the internal call function passed to provider clients.
+CallFn = Callable[[str, str, Optional[Dict[str, Any]]], Any]

leash_sdk-0.1.0/leash_sdk.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: leash-sdk
+Version: 0.1.0
+Summary: Leash platform SDK - access Gmail, Calendar, Drive and more from deployed apps
+License: MIT
+Project-URL: Homepage, https://leash.build
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Dynamic: requires-python
+
+# Leash SDK (Python)
+
+Python SDK for accessing platform integrations (Gmail, Google Calendar, Google Drive) from apps deployed on [Leash](https://leash.build).
+
+## Install
+
+```bash
+pip install leash-sdk
+```
+
+## Usage
+
+```python
+from leash import LeashIntegrations
+
+# Get the auth token from the leash-auth cookie (e.g. in Flask/Django)
+integrations = LeashIntegrations(auth_token="your-jwt-token")
+
+# Gmail
+emails = integrations.gmail.list_messages(max_results=10)
+integrations.gmail.send_message(to="user@example.com", subject="Hello", body="World")
+
+# Calendar
+events = integrations.calendar.list_events(time_min="2026-04-01T00:00:00Z")
+integrations.calendar.create_event(
+    summary="Meeting",
+    start="2026-04-10T10:00:00Z",
+    end="2026-04-10T11:00:00Z",
+)
+
+# Drive
+files = integrations.drive.list_files(max_results=10)
+integrations.drive.upload_file(name="notes.txt", content="hello", mime_type="text/plain")
+```
+
+## How it works
+
+The SDK calls the Leash platform proxy at `https://api.leash.build/api/integrations/{provider}/{action}`. The platform handles all OAuth token management -- the SDK just passes the user's auth token and makes typed API calls.

leash_sdk-0.1.0/leash_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+setup.py
+leash/__init__.py
+leash/calendar.py
+leash/client.py
+leash/drive.py
+leash/gmail.py
+leash/types.py
+leash_sdk.egg-info/PKG-INFO
+leash_sdk.egg-info/SOURCES.txt
+leash_sdk.egg-info/dependency_links.txt
+leash_sdk.egg-info/requires.txt
+leash_sdk.egg-info/top_level.txt

leash_sdk-0.1.0/leash_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

leash_sdk-0.1.0/leash_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28

leash_sdk-0.1.0/leash_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+leash

leash_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "leash-sdk"
+version = "0.1.0"
+description = "Leash platform SDK - access Gmail, Calendar, Drive and more from deployed apps"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+dependencies = [
+    "requests>=2.28",
+]
+
+[project.urls]
+Homepage = "https://leash.build"
+
+[tool.setuptools.packages.find]
+include = ["leash*"]

leash_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

leash_sdk-0.1.0/setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="leash-sdk",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=["requests>=2.28"],
+    python_requires=">=3.8",
+)