flowwatch-client 2.1.0__py3-none-any.whl

flowwatch/__init__.py

@@ -0,0 +1,3 @@
+from .client import AsyncFlowwatchClient, FlowwatchClient
+
+__all__ = ["FlowwatchClient", "AsyncFlowwatchClient"]

flowwatch/client.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import time
+from contextlib import contextmanager
+from typing import Any, Generator
+
+import httpx
+
+
+class FlowwatchClient:
+    """Synchronous FlowWatch sidecar client. Use as a context manager for connection cleanup."""
+
+    def __init__(self, base_url: str = "http://localhost:9400", token: str | None = None) -> None:
+        headers = {"Authorization": f"Bearer {token}"} if token else {}
+        self._http = httpx.Client(base_url=base_url, headers=headers)
+
+    def evaluate_flag(self, key: str, context: dict[str, Any] | None = None) -> bool:
+        r = self._http.post("/api/flag", json={"key": key, "context": context or {}})
+        r.raise_for_status()
+        return bool(r.json().get("enabled", False))
+
+    def trigger_workflow(self, name: str, input: Any = None) -> dict[str, Any]:
+        r = self._http.post("/api/trigger", json={"name": name, "input": input})
+        r.raise_for_status()
+        return r.json()
+
+    def log_trace_span(
+        self,
+        name: str,
+        type: str,
+        duration_ms: float,
+        status: str = "ok",
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        r = self._http.post(
+            "/api/trace-span",
+            json={"name": name, "type": type, "durationMs": duration_ms, "status": status, "metadata": metadata},
+        )
+        r.raise_for_status()
+
+    def capture_error(
+        self,
+        message: str,
+        name: str = "Error",
+        stack: str | None = None,
+        source: str | None = None,
+        **options: Any,
+    ) -> None:
+        r = self._http.post(
+            "/api/capture-error",
+            json={
+                "error": {"message": message, "name": name, "stack": stack},
+                "options": {"source": source, **options},
+            },
+        )
+        r.raise_for_status()
+
+    def health(self) -> dict[str, Any]:
+        r = self._http.get("/api/health")
+        r.raise_for_status()
+        return r.json()
+
+    @contextmanager
+    def trace_span(
+        self, name: str, type: str, metadata: dict[str, Any] | None = None
+    ) -> Generator[None, None, None]:
+        """Auto-times the wrapped block and submits a trace span on exit."""
+        start = time.monotonic()
+        status = "ok"
+        try:
+            yield
+        except Exception:
+            status = "error"
+            raise
+        finally:
+            self.log_trace_span(name, type, (time.monotonic() - start) * 1000, status, metadata)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> FlowwatchClient:
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+
+class AsyncFlowwatchClient:
+    """Async FlowWatch sidecar client. Use as an async context manager for connection cleanup."""
+
+    def __init__(self, base_url: str = "http://localhost:9400", token: str | None = None) -> None:
+        headers = {"Authorization": f"Bearer {token}"} if token else {}
+        self._http = httpx.AsyncClient(base_url=base_url, headers=headers)
+
+    async def evaluate_flag(self, key: str, context: dict[str, Any] | None = None) -> bool:
+        r = await self._http.post("/api/flag", json={"key": key, "context": context or {}})
+        r.raise_for_status()
+        return bool(r.json().get("enabled", False))
+
+    async def trigger_workflow(self, name: str, input: Any = None) -> dict[str, Any]:
+        r = await self._http.post("/api/trigger", json={"name": name, "input": input})
+        r.raise_for_status()
+        return r.json()
+
+    async def log_trace_span(
+        self,
+        name: str,
+        type: str,
+        duration_ms: float,
+        status: str = "ok",
+        metadata: dict[str, Any] | None = None,
+    ) -> None:
+        r = await self._http.post(
+            "/api/trace-span",
+            json={"name": name, "type": type, "durationMs": duration_ms, "status": status, "metadata": metadata},
+        )
+        r.raise_for_status()
+
+    async def capture_error(
+        self,
+        message: str,
+        name: str = "Error",
+        stack: str | None = None,
+        source: str | None = None,
+        **options: Any,
+    ) -> None:
+        r = await self._http.post(
+            "/api/capture-error",
+            json={
+                "error": {"message": message, "name": name, "stack": stack},
+                "options": {"source": source, **options},
+            },
+        )
+        r.raise_for_status()
+
+    async def health(self) -> dict[str, Any]:
+        r = await self._http.get("/api/health")
+        r.raise_for_status()
+        return r.json()
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> AsyncFlowwatchClient:
+        return self
+
+    async def __aexit__(self, *_: Any) -> None:
+        await self.aclose()

flowwatch_client-2.1.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: flowwatch-client
+Version: 2.1.0
+Summary: Python client SDK for FlowWatch — feature flags, durable workflows, tracing, and error capture
+Project-URL: Homepage, https://github.com/PranshulSoni/flowwatch
+Project-URL: Issues, https://github.com/PranshulSoni/flowwatch/issues
+License: ISC
+Requires-Python: >=3.8
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# flowwatch (Python)
+
+Python client for [FlowWatch](https://github.com/PranshulSoni/flowwatch). Wraps the FlowWatch sidecar REST API — requires the [sidecar server](https://github.com/PranshulSoni/flowwatch#multi-language-support-sidecar-server) to be running.
+
+## Install
+
+```bash
+pip install flowwatch-client
+```
+
+## Usage
+
+```python
+from flowwatch import FlowwatchClient
+
+client = FlowwatchClient("http://localhost:9400", token="your-sidecar-token")
+
+# Feature flag
+if client.evaluate_flag("new-billing-flow", {"userId": "u123", "plan": "pro"}):
+    use_new_flow()
+
+# Durable workflow
+result = client.trigger_workflow("checkout", {"cartId": "cart_1"})
+print(result["executionId"])
+
+# Auto-timed trace span
+with client.trace_span("process-order", "function"):
+    process_order()
+
+# Error capture
+try:
+    risky()
+except Exception as e:
+    import traceback
+    client.capture_error(str(e), stack=traceback.format_exc(), source="my-service")
+
+# Health check
+print(client.health())
+
+client.close()
+```
+
+### Async
+
+```python
+from flowwatch import AsyncFlowwatchClient
+
+async with AsyncFlowwatchClient("http://localhost:9400", token="your-token") as client:
+    enabled = await client.evaluate_flag("dark-mode", {"userId": "u1"})
+    result = await client.trigger_workflow("send-email", {"to": "user@example.com"})
+```

flowwatch_client-2.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+flowwatch/__init__.py,sha256=G0IrIF7Qn5hnx9ZssTLITUMsqoRU1sieEq9Otn4zuHk,113
+flowwatch/client.py,sha256=xPSvXa1pzyPXpANowBHF7ZmEiFCVZuYo55VGL1b7zbw,4811
+flowwatch_client-2.1.0.dist-info/METADATA,sha256=H6IXA_AI-4zonnGANM9Ti1O4eVtYSzlhArxJoM4dhao,1725
+flowwatch_client-2.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+flowwatch_client-2.1.0.dist-info/RECORD,,

flowwatch_client-2.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any