trigora-client 1.0.0__py3-none-any.whl

trigora_client/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from .client import (
+    DEFAULT_CLOUD_API_URL,
+    DEFAULT_RUNTIME_URL,
+    Client,
+    ExecutionHandle,
+    TrigoraError,
+    start,
+)
+
+__all__ = [
+    "DEFAULT_CLOUD_API_URL",
+    "DEFAULT_RUNTIME_URL",
+    "Client",
+    "ExecutionHandle",
+    "TrigoraError",
+    "start",
+]

trigora_client/client.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any
+
+DEFAULT_RUNTIME_URL = "http://127.0.0.1:3477"
+DEFAULT_CLOUD_API_URL = "https://api.trigora.dev"
+_PROJECT_HEADER = "X-Trigora-Project-Id"
+
+
+class TrigoraError(RuntimeError):
+    def __init__(self, message: str, *, status: int = 0, code: str | None = None) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+
+
+def _present(value: str | None) -> str | None:
+    if value is None:
+        return None
+    trimmed = value.strip()
+    return trimmed or None
+
+
+def _env_url(name: str, fallback: str) -> str:
+    return (_present(os.environ.get(name)) or fallback).rstrip("/")
+
+
+def _resolve(url: str | None, token: str | None, remote: bool) -> tuple[str, str | None, bool]:
+    explicit_token = _present(token)
+    if url:
+        return url.rstrip("/"), explicit_token, False
+    if remote:
+        resolved = explicit_token or _present(os.environ.get("TRIGORA_TOKEN"))
+        if not resolved:
+            raise TrigoraError("TRIGORA_TOKEN is not set.")
+        return _env_url("TRIGORA_API_BASE_URL", DEFAULT_CLOUD_API_URL), resolved, True
+    return _env_url("TRIGORA_RUNTIME_URL", DEFAULT_RUNTIME_URL), explicit_token, False
+
+
+class Client:
+    def __init__(
+        self,
+        *,
+        url: str | None = None,
+        remote: bool = False,
+        token: str | None = None,
+        project_id: str | None = None,
+    ) -> None:
+        resolved_url, resolved_token, cloud = _resolve(url, token, remote)
+        self.url = resolved_url
+        self.token = resolved_token
+        self.cloud = cloud
+        self.project_id = project_id
+        self.projects = Projects(self)
+        self.programs = Programs(self)
+        self.executions = Executions(self)
+
+    def whoami(self) -> dict[str, Any]:
+        return self._request("GET", "/v1/whoami")
+
+    def deploy(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", "/v1/programs/deploy", body)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        payload: dict[str, Any] | None = None,
+        query: dict[str, str] | None = None,
+    ) -> Any:
+        target = f"{self.url}{path}"
+        if query:
+            target = f"{target}?{urllib.parse.urlencode(query)}"
+        data = None if payload is None else json.dumps(payload).encode("utf-8")
+        headers = {"Accept": "application/json"}
+        if payload is not None:
+            headers["Content-Type"] = "application/json"
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        if self.project_id:
+            headers[_PROJECT_HEADER] = self.project_id
+        request = urllib.request.Request(target, data=data, method=method, headers=headers)
+        try:
+            with urllib.request.urlopen(request) as response:
+                body = response.read().decode("utf-8")
+                return json.loads(body) if body else None
+        except urllib.error.HTTPError as error:
+            raw = error.read().decode("utf-8")
+            message = raw or str(error)
+            code = None
+            try:
+                parsed = json.loads(raw)
+                message = parsed.get("error", {}).get("message") or message
+                code = parsed.get("error", {}).get("code")
+            except json.JSONDecodeError:
+                pass
+            raise TrigoraError(message, status=error.code or 0, code=code) from error
+        except urllib.error.URLError as error:
+            if self.cloud:
+                message = f"Could not reach Trigora Cloud at {target}. {error.reason}"
+            else:
+                message = (
+                    f"Could not reach the local Trigora runtime at {target}. "
+                    f"Is `trigora dev` running? {error.reason}"
+                )
+            raise TrigoraError(message, status=0) from error
+
+
+class Projects:
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def list(self) -> dict[str, Any]:
+        return self._client._request("GET", "/v1/projects")
+
+    def create(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._client._request("POST", "/v1/projects", body)
+
+
+class Programs:
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def list(self, *, limit: int | None = None, cursor: str | None = None) -> dict[str, Any]:
+        return self._client._request("GET", "/v1/programs", query=_page(limit, cursor))
+
+    def get(self, program_id: str) -> dict[str, Any]:
+        return self._client._request("GET", f"/v1/programs/{urllib.parse.quote(program_id)}")
+
+    def versions(
+        self, program_id: str, *, limit: int | None = None, cursor: str | None = None
+    ) -> dict[str, Any]:
+        return self._client._request(
+            "GET",
+            f"/v1/programs/{urllib.parse.quote(program_id)}/versions",
+            query=_page(limit, cursor),
+        )
+
+
+class Executions:
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def start(self, program_id: str, input: Any | None = None) -> ExecutionHandle:
+        body = self._client._request(
+            "POST",
+            "/v1/executions",
+            {"programId": program_id, "input": {} if input is None else input},
+        )
+        return ExecutionHandle(self._client, body["execution"]["id"])
+
+    def get(self, execution_id: str) -> dict[str, Any]:
+        body = self._client._request("GET", f"/v1/executions/{urllib.parse.quote(execution_id)}")
+        return body["execution"]
+
+    def list(self, *, limit: int | None = None, cursor: str | None = None) -> dict[str, Any]:
+        return self._client._request("GET", "/v1/executions", query=_page(limit, cursor))
+
+    def send(self, execution_id: str, name: str, payload: Any = None) -> dict[str, Any]:
+        return self._client._request(
+            "POST",
+            f"/v1/executions/{urllib.parse.quote(execution_id)}/events",
+            {"name": name, "payload": {} if payload is None else payload},
+        )
+
+    def cancel(self, execution_id: str) -> dict[str, Any]:
+        return self._client._request(
+            "POST",
+            f"/v1/executions/{urllib.parse.quote(execution_id)}/cancel",
+            {},
+        )
+
+    def result(self, execution_id: str, *, poll_seconds: float = 0.05) -> Any:
+        return ExecutionHandle(self._client, execution_id).result(poll_seconds=poll_seconds)
+
+
+class ExecutionHandle:
+    def __init__(self, client: Client, execution_id: str) -> None:
+        self._client = client
+        self.id = execution_id
+
+    def send(self, name: str, payload: Any = None) -> None:
+        self._client.executions.send(self.id, name, payload)
+
+    def cancel(self) -> None:
+        self._client.executions.cancel(self.id)
+
+    def result(self, *, poll_seconds: float = 0.05) -> Any:
+        while True:
+            execution = self._client.executions.get(self.id)
+            status = execution["status"]
+            if status == "completed":
+                return execution.get("result")
+            if status == "failed":
+                error = execution.get("error") or {}
+                raise TrigoraError(error.get("message") or "Execution failed.")
+            if status == "cancelled":
+                raise TrigoraError(f'Execution "{self.id}" was cancelled.', status=409)
+            time.sleep(poll_seconds)
+
+
+def start(
+    program_id: str,
+    input: Any | None = None,
+    *,
+    url: str | None = None,
+    remote: bool = False,
+    token: str | None = None,
+) -> ExecutionHandle:
+    return Client(url=url, remote=remote, token=token).executions.start(program_id, input)
+
+
+def _page(limit: int | None, cursor: str | None) -> dict[str, str] | None:
+    query: dict[str, str] = {}
+    if limit is not None:
+        query["limit"] = str(limit)
+    if cursor:
+        query["cursor"] = cursor
+    return query or None

trigora_client-1.0.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: trigora-client
+Version: 1.0.0
+Summary: Python client for Trigora Cloud and the local runtime
+Author: Trigora
+License: MIT
+Project-URL: Homepage, https://trigora.dev
+Project-URL: Repository, https://github.com/trigora-dev/trigora-python
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# trigora-client
+
+Python client for starting and controlling Trigora durable executions.
+
+Use the same API locally with `trigora dev` or remotely with Trigora Cloud.
+
+## Install
+
+```bash
+pip install trigora-client
+```
+
+## Quick example
+
+```python
+from trigora_client import Client
+
+client = Client()
+
+run = client.executions.start("approval", {"request": "example"})
+run.send("approved", "ok")
+result = run.result()
+
+print(result)
+```
+
+## Local and Cloud
+
+By default, the client connects to the local runtime started by `trigora dev`.
+
+```python
+client = Client()
+```
+
+To connect to Trigora Cloud:
+
+```python
+client = Client(remote=True)
+```
+
+Cloud requires a token. You can pass one directly or set `TRIGORA_TOKEN`.
+
+```python
+import os
+
+client = Client(remote=True, token=os.environ["TRIGORA_TOKEN"])
+```
+
+You can also connect to a custom endpoint:
+
+```python
+client = Client(url="http://127.0.0.1:3477")
+```
+
+Endpoint defaults:
+
+- Local runtime: `TRIGORA_RUNTIME_URL` or `http://127.0.0.1:3477`
+- Trigora Cloud: `TRIGORA_API_BASE_URL` or `https://api.trigora.dev`
+
+An explicit `url` overrides the default endpoint. An explicit `token` is sent with requests to that endpoint.
+
+## API
+
+Workspace and project operations:
+
+- `whoami()`
+- `projects.list()`
+- `projects.create()`
+
+Programs:
+
+- `deploy()`
+- `programs.list()`
+- `programs.get()`
+- `programs.versions()`
+
+Executions:
+
+- `executions.start(program, input)`
+- `executions.list()`
+- `executions.get(id)`
+
+Execution handle:
+
+- `run.id`
+- `run.send(event, payload)`
+- `run.cancel()`
+- `run.result()`
+
+`programs.list`, `programs.versions`, and `executions.list` accept optional `limit` and `cursor` arguments.
+
+`program` is a program id string.
+
+`event` is an event name string.
+
+## Learn more
+
+- [Trigora documentation](https://trigora.dev/docs)
+- [Client documentation](https://trigora.dev/docs/client)
+- [Trigora Cloud](https://cloud.trigora.dev)
+
+## License
+
+MIT © 2026 Trigora, Inc.

trigora_client-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+trigora_client/__init__.py,sha256=KtlJYGzLx6s1imJbybwoncY5FJshQhx8Fc3cELyS0zI,315
+trigora_client/client.py,sha256=QU0_lM8oMobG5lbCv-d4olMHd5pV_MsFAIwcKL8MmPQ,8000
+trigora_client-1.0.0.dist-info/METADATA,sha256=zBrWBCReTr8jPzyj2jbRKNClv7ApptR8jW5HQrZGWhg,2370
+trigora_client-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+trigora_client-1.0.0.dist-info/top_level.txt,sha256=sy8v7bmk0gRttoIXirS_9rmvwPgfNbXs9DcBFrvNKsI,15
+trigora_client-1.0.0.dist-info/RECORD,,

trigora_client-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

trigora_client-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+trigora_client