driftstone 0.1.0__tar.gz

driftstone-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

driftstone-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

driftstone-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: driftstone
+Version: 0.1.0
+Summary: Python SDK for the Driftstone API.
+Project-URL: Homepage, https://www.driftstone.ai/
+Author: Driftstone
+Keywords: api-client,driftstone,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx<1.0,>=0.27
+Description-Content-Type: text/markdown
+
+## Driftstone - Python
+
+Python SDK for the Driftstone API.
+
+### Install
+
+```bash
+pip install driftstone
+```
+
+### Quick Start
+
+```python
+from driftstone import Driftstone
+
+client = Driftstone(api_key="your-api-key")
+
+app = client.app.init("typedef-app", 
+    type="claude", 
+    version_path=".openclaw"
+)
+
+channel = app.channel.init("my-api", 
+    type="api"
+)
+
+stream = channel.run(
+    session_id="my-custom-session-id",
+    user_id="stephen@pickaxe.co",
+    input="hello world"
+)
+
+for event in stream:
+    if event.done:
+        break
+
+    print(event)
+
+```
+
+### Using A Context Manager
+
+```python
+from driftstone import Driftstone
+
+with Driftstone(api_key="your-api-key") as client:
+    app = client.app.init("typedef-app", 
+        type="claude", 
+        version_path=".openclaw"
+    )
+
+    channel = app.channel.init("my-api", 
+        type="api"
+    )
+
+    stream = channel.run(
+        session_id="my-custom-session-id",
+        user_id="stephen@pickaxe.co",
+        input="hello world"
+    )
+
+    for event in stream:
+        if event.done:
+            break
+
+        print(event)
+    
+```

driftstone-0.1.0/README.md

@@ -0,0 +1,68 @@
+## Driftstone - Python
+
+Python SDK for the Driftstone API.
+
+### Install
+
+```bash
+pip install driftstone
+```
+
+### Quick Start
+
+```python
+from driftstone import Driftstone
+
+client = Driftstone(api_key="your-api-key")
+
+app = client.app.init("typedef-app", 
+    type="claude", 
+    version_path=".openclaw"
+)
+
+channel = app.channel.init("my-api", 
+    type="api"
+)
+
+stream = channel.run(
+    session_id="my-custom-session-id",
+    user_id="stephen@pickaxe.co",
+    input="hello world"
+)
+
+for event in stream:
+    if event.done:
+        break
+
+    print(event)
+
+```
+
+### Using A Context Manager
+
+```python
+from driftstone import Driftstone
+
+with Driftstone(api_key="your-api-key") as client:
+    app = client.app.init("typedef-app", 
+        type="claude", 
+        version_path=".openclaw"
+    )
+
+    channel = app.channel.init("my-api", 
+        type="api"
+    )
+
+    stream = channel.run(
+        session_id="my-custom-session-id",
+        user_id="stephen@pickaxe.co",
+        input="hello world"
+    )
+
+    for event in stream:
+        if event.done:
+            break
+
+        print(event)
+    
+```

driftstone-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling>=1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "driftstone"
+dynamic = ["version"]
+description = "Python SDK for the Driftstone API."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "httpx>=0.27,<1.0",
+]
+authors = [
+  { name = "Driftstone" },
+]
+keywords = ["driftstone", "sdk", "api-client"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://www.driftstone.ai/"
+
+[tool.hatch.version]
+path = "src/driftstone/version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/driftstone"]

driftstone-0.1.0/src/driftstone/__init__.py

@@ -0,0 +1,15 @@
+from .client import Driftstone
+from .exceptions import (
+    DriftstoneAPIError,
+    DriftstoneError,
+    DriftstoneHTTPError,
+    DriftstoneResponseError,
+)
+
+__all__ = [
+    "Driftstone",
+    "DriftstoneError",
+    "DriftstoneHTTPError",
+    "DriftstoneResponseError",
+    "DriftstoneAPIError",
+]

driftstone-0.1.0/src/driftstone/_internal/__init__.py

@@ -0,0 +1 @@
+"""Internal Driftstone SDK implementation details."""

driftstone-0.1.0/src/driftstone/_internal/constants.py

@@ -0,0 +1,7 @@
+DEFAULT_API_BASE_URL = "https://pickaxeproject--driftstone-api-api.modal.run"
+
+GCS_BUCKET_NAME = "driftstone"
+
+AVAILABLE_APP_TYPES = ("claude", "openclaw")
+
+AVAILABLE_CHANNEL_TYPES = ("api", "imessage")

driftstone-0.1.0/src/driftstone/_internal/transport.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import Any, Literal, cast
+import httpx
+
+from .utils import logger
+from ..exceptions import (
+    DriftstoneAPIError, 
+    DriftstoneHTTPError, 
+    DriftstoneResponseError
+)
+
+Method = Literal["GET", "POST", "PUT", "PATCH", "DELETE"]
+
+class Transport:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        timeout: float,
+        user_agent: str,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        self.timeout = timeout
+        self._headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": user_agent,
+        }
+        self._owns_http_client = http_client is None
+        self._http = http_client or httpx.Client(
+            base_url=base_url,
+            timeout=timeout,
+            headers=self._headers,
+        )
+
+    @property
+    def headers(self) -> dict[str, str]:
+        return self._headers.copy()
+
+    def close(self) -> None:
+        if self._owns_http_client:
+            self._http.close()
+
+    @staticmethod
+    def _parse_response(response: httpx.Response) -> dict[str, Any]:
+        try:
+            decoded = response.json()
+        except ValueError as exc:
+            raise DriftstoneResponseError(
+                f"Driftstone API returned non-JSON response (status={response.status_code})"
+            ) from exc
+
+        if not isinstance(decoded, dict):
+            raise DriftstoneResponseError(
+                "Driftstone API returned an unexpected response payload"
+            )
+
+        return cast(dict[str, Any], decoded)
+
+    def request(
+        self,
+        method: Method,
+        path: str,
+        payload: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        payload = payload or {}
+
+        try:
+            kwargs: dict[str, Any] = {
+                "method": method,
+                "url": path,
+                "headers": self._headers,
+            }
+            if method == "GET":
+                kwargs["params"] = payload
+            else:
+                kwargs["json"] = payload
+
+            response = self._http.request(**kwargs)
+        except httpx.HTTPError as exc:
+            raise DriftstoneHTTPError(f"HTTP request failed: {exc}") from exc
+
+        data = self._parse_response(response)
+
+        logger.debug(
+            "Received response from Driftstone API (status=%d, data=%s)",
+            response.status_code,
+            data,
+        )
+
+        if response.status_code >= 400:
+            raise DriftstoneAPIError(
+                f"Driftstone API returned error status {response.status_code}: {data}"
+            )
+
+        if data.get("success") is False:
+            message = str(data.get("error") or data.get("message") or "Request failed")
+            raise DriftstoneAPIError(f"Driftstone API error: {message}")
+
+        return data

driftstone-0.1.0/src/driftstone/_internal/utils.py

@@ -0,0 +1,21 @@
+import logging
+import json
+
+logger = logging.getLogger("driftstone")
+logger.setLevel(logging.WARNING)
+logger.addHandler(logging.NullHandler())
+
+logging.basicConfig(
+    format="[%(funcName)s][%(asctime)s]: %(levelname)s %(message)s",
+    datefmt="%m/%d/%Y %H:%M:%S",
+)
+
+def set_debug(enabled: bool) -> None:
+    logger.setLevel(logging.INFO if enabled else logging.WARNING)
+
+def safe_parse_json(raw: str):
+    try:
+        return json.loads(raw)
+    except Exception as e:
+        logger.error("Failed to parse JSON: %s", e)
+        return None

driftstone-0.1.0/src/driftstone/client.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+import httpx
+
+from ._internal.constants import DEFAULT_API_BASE_URL
+from ._internal.utils import logger, set_debug
+from ._internal.transport import Method, Transport
+from .resources.app import DriftstoneApp
+from .version import __version__
+
+class Driftstone:
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        version: Literal["v1"] = "v1",
+        timeout: float = 30.0,
+        debug: bool = False,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        self.debug = debug
+        set_debug(self.debug)
+        
+        logger.info("Initializing Driftstone client with provided API key")
+
+        trimmed_key = api_key.strip()
+        if not trimmed_key:
+            raise ValueError("api_key must be provided")
+        if not trimmed_key.startswith("dk-"):
+            raise ValueError("Invalid Driftstone API key")
+
+        self.api_key = trimmed_key
+        self.version = version
+        self.timeout = timeout
+        self.base_url = f"{DEFAULT_API_BASE_URL}/{self.version}"
+
+        self._transport = Transport(
+            base_url=self.base_url,
+            api_key=self.api_key,
+            timeout=self.timeout,
+            user_agent=f"Driftstone-python/{__version__}",
+            http_client=http_client,
+        )
+
+    def close(self) -> None:
+        self._transport.close()
+
+    def __enter__(self) -> "Driftstone":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def _request(
+        self,
+        method: Method,
+        path: str,
+        payload: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return self._transport.request(method, path, payload)
+
+    @property
+    def app(self) -> DriftstoneApp:
+        return DriftstoneApp(self)
+    

driftstone-0.1.0/src/driftstone/exceptions.py

@@ -0,0 +1,14 @@
+class DriftstoneError(Exception):
+    """Base exception for the Driftstone SDK."""
+
+
+class DriftstoneHTTPError(DriftstoneError):
+    """Raised when the underlying HTTP request fails."""
+
+
+class DriftstoneResponseError(DriftstoneError):
+    """Raised when an API response cannot be parsed as expected."""
+
+
+class DriftstoneAPIError(DriftstoneError):
+    """Raised when the Driftstone API returns an error."""

driftstone-0.1.0/src/driftstone/models/__init__.py

@@ -0,0 +1 @@
+"""Driftstone SDK models."""

driftstone-0.1.0/src/driftstone/models/access_group.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Literal, Mapping
+
+AccessGroupLimitReset = Literal["daily", "monthly", "yearly"]
+
+
+@dataclass(frozen=True, slots=True)
+class DriftstoneAccessGroupModel:
+    id: str
+    appId: str
+    name: str
+    limit: int
+    limitReset: AccessGroupLimitReset
+    limitMessage: str
+    createdAt: datetime
+    updatedAt: datetime
+
+    @classmethod
+    def _from_api(cls, payload: Mapping[str, Any]) -> "DriftstoneAccessGroupModel":
+        return cls(
+            id=payload["id"],
+            appId=payload["appId"],
+            name=payload["name"],
+            limit=payload["limit"],
+            limitReset=payload["limitReset"],
+            limitMessage=payload["limitMessage"],
+            createdAt=datetime.fromisoformat(payload["createdAt"]),
+            updatedAt=datetime.fromisoformat(payload["updatedAt"]),
+        )

driftstone-0.1.0/src/driftstone/models/app.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import (
+    TYPE_CHECKING, 
+    Any, 
+    Literal, 
+    Mapping, 
+    Optional, 
+    TypedDict,
+    Union,
+    Required,
+)
+
+if TYPE_CHECKING:
+    from ..resources.access_group import DriftstoneAccessGroup
+    from ..resources.version import DriftstoneVersion
+    from ..resources.channel import DriftstoneChannel
+    from ..resources.session import DriftstoneSession
+    from ..resources.profile import DriftstoneProfile
+    from ..resources.instance import DriftstoneInstance
+
+ApplicationType = Literal["claude", "openclaw"]
+
+class AppInitLimit(TypedDict):
+    name: Optional[str]
+    amount: Required[int]
+    interval: Required[Literal["daily", "weekly", "monthly"]]
+    message: Optional[str]
+
+class AppInitCredentialMCPOAuthNoneParam(TypedDict):
+    type: Required[Literal["none"]]
+
+class AppInitCredentialMCPOAuthBasicParam(TypedDict):
+    type: Required[Literal["client_secret_basic"]]
+    client_secret: Required[str]
+
+class AppInitCredentialMCPOAuthPostParam(TypedDict):
+    type: Required[Literal["client_secret_post"]]
+    client_secret: Required[str]
+
+class AppInitCredentialMCPOAuthRefresh(TypedDict):
+    client_id: Required[str]
+    refresh_token: Required[str]
+    token_endpoint: Required[str]
+    token_endpoint_auth: Required[Union[
+        AppInitCredentialMCPOAuthNoneParam,
+        AppInitCredentialMCPOAuthBasicParam,
+        AppInitCredentialMCPOAuthPostParam,
+    ]]
+    resource: Optional[str]
+    scope: Optional[str]
+
+class AppInitCredentialMCPOAuth(TypedDict):
+    access_token: Required[str]
+    mcp_server_url: Required[str]
+    type: Required[Literal["mcp_oauth"]]
+    expires_at: Optional[datetime]
+    refresh: Optional[AppInitCredentialMCPOAuthRefresh]
+
+class AppInitCredentialMCPStaticBearer(TypedDict):
+    token: Required[str]
+    mcp_server_url: Required[str]
+    type: Required[Literal["mcp_oauth"]]
+
+AppInitCredential = Union[AppInitCredentialMCPOAuth, AppInitCredentialMCPStaticBearer]
+
+@dataclass(frozen=True, slots=True)
+class DriftstoneAppModel:
+    id: str
+    orgId: str
+    type: ApplicationType
+    name: str
+    slug: str
+    vaultId: str
+    defaultAccessGroupId: str
+    headVersionId: Optional[str]
+    metadata: Optional[dict[str, str]]
+    createdAt: datetime
+    updatedAt: datetime
+
+    version: DriftstoneVersion
+    channel: DriftstoneChannel
+    session: DriftstoneSession
+    access_group: DriftstoneAccessGroup
+    profile: DriftstoneProfile
+    instance: DriftstoneInstance
+
+    @classmethod
+    def _from_api(
+        cls,
+        payload: Mapping[str, Any],
+        version: DriftstoneVersion,
+        channel: DriftstoneChannel,
+        session: DriftstoneSession,
+        access_group: DriftstoneAccessGroup,
+        profile: DriftstoneProfile,
+        instance: DriftstoneInstance,
+    ) -> "DriftstoneAppModel":
+        return cls(
+            id=payload["id"],
+            orgId=payload["orgId"],
+            type=payload["type"],
+            name=payload["name"],
+            slug=payload["slug"],
+            vaultId=payload["vaultId"],
+            defaultAccessGroupId=payload["defaultAccessGroupId"],
+            headVersionId=payload.get("headVersionId"),
+            metadata=payload.get("metadata"),
+            createdAt=datetime.fromisoformat(payload["createdAt"]),
+            updatedAt=datetime.fromisoformat(payload["updatedAt"]),
+            
+            version=version,
+            channel=channel,
+            session=session,
+            access_group=access_group,
+            profile=profile,
+            instance=instance,
+        )