sepurux 0.2.0__tar.gz

sepurux-0.2.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: sepurux
+Version: 0.2.0
+Summary: Python SDK for Sepurux trace recording and uploads
+Author: Sepurux
+License: MIT
+Project-URL: Homepage, https://github.com/felixkwasisarpong/Sepurux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1,>=0.27
+
+# Sepurux Python SDK
+
+Python SDK for recording Sepurux traces and uploading them to a Sepurux API.
+
+## Install
+
+```bash
+pip install -e sdk
+```
+
+## Quick start
+
+```python
+from sepurux import SepuruxClient, sepurux_trace
+
+client = SepuruxClient(
+    base_url="http://localhost:8000",
+    api_key="sepurux-dev-key",
+    project_id="22222222-2222-2222-2222-222222222222",
+)
+
+with sepurux_trace("example_task", {"user_id": "u-123"}) as rec:
+    rec.model_step("plan", {"goal": "create issue"}, output={"ok": True})
+    rec.tool_call("jira.create_issue(commit)", {"summary": "SDK test"})
+    rec.tool_result("jira.create_issue(commit)", {"issue_id": "OPS-123"})
+
+trace_id = client.upload_trace(rec.to_trace())
+print("trace_id:", trace_id)
+```
+
+## API
+
+### `SepuruxClient`
+
+```python
+SepuruxClient(base_url, api_key=None, project_id=None, timeout=30, sdk_header=None)
+```
+
+The SDK automatically sends `X-Sepurux-SDK: py/<version>` on requests.
+Use `sdk_header` only if you need to override it manually.
+
+Methods:
+- `upload_trace(trace: dict) -> str`
+- `create_campaign(name, mutation_set, eval_set, mutation_pack_id=None) -> str`
+- `start_run(trace_id, campaign_id, thresholds=None) -> str`
+- `get_run(run_id) -> dict`
+
+### `TraceBuilder`
+
+`TraceBuilder` outputs backend-compatible traces:
+
+```json
+{
+  "trace_version": "0.1",
+  "source": "sdk",
+  "task": {"name": "...", "input": {}},
+  "events": []
+}
+```
+
+### Recorder
+
+Use a context manager:
+
+```python
+from sepurux import sepurux_trace
+
+with sepurux_trace("task_name", {"input": "value"}) as rec:
+    rec.model_step("name", {"foo": "bar"}, output={"ok": True})
+    rec.tool_call("tool.name", {"arg": 1})
+    rec.tool_result("tool.name", {"result": "ok"})
+    rec.error(message="something happened", tool="tool.name")
+```
+
+### Decorator
+
+```python
+from sepurux import record_trace
+
+@record_trace(client=client, campaign_id="<campaign_id>")
+def run_business_logic(x: int) -> int:
+    return x * 2
+```
+
+The decorator preserves the function return value and attempts to upload/start runs in the background path without interrupting normal execution.
+
+## Example script
+
+See `examples/sdk_demo.py`.
+
+```bash
+python sdk/examples/sdk_demo.py
+```
+
+Optional environment variables:
+- `SEPURUX_API_BASE_URL` (default `http://localhost:8000`)
+- `SEPURUX_UI_BASE_URL` (default `http://localhost:3000`)
+- `SEPURUX_API_KEY`
+- `SEPURUX_PROJECT_ID`
+- `SEPURUX_CAMPAIGN_ID` (if provided, script starts a run)
+
+## Publish to PyPI (CI)
+
+This repository includes `.github/workflows/sdk-publish-pypi.yml` to publish the SDK directly to PyPI.
+
+Setup:
+- Add `PYPI_API_TOKEN` in GitHub repository secrets.
+- Ensure the package version in `sdk/pyproject.toml` is new.
+
+Release:
+- Push a tag like `sdk-v0.2.0` to trigger publish.
+- Or run the workflow manually from GitHub Actions.

sepurux-0.2.0/README.md

@@ -0,0 +1,112 @@
+# Sepurux Python SDK
+
+Python SDK for recording Sepurux traces and uploading them to a Sepurux API.
+
+## Install
+
+```bash
+pip install -e sdk
+```
+
+## Quick start
+
+```python
+from sepurux import SepuruxClient, sepurux_trace
+
+client = SepuruxClient(
+    base_url="http://localhost:8000",
+    api_key="sepurux-dev-key",
+    project_id="22222222-2222-2222-2222-222222222222",
+)
+
+with sepurux_trace("example_task", {"user_id": "u-123"}) as rec:
+    rec.model_step("plan", {"goal": "create issue"}, output={"ok": True})
+    rec.tool_call("jira.create_issue(commit)", {"summary": "SDK test"})
+    rec.tool_result("jira.create_issue(commit)", {"issue_id": "OPS-123"})
+
+trace_id = client.upload_trace(rec.to_trace())
+print("trace_id:", trace_id)
+```
+
+## API
+
+### `SepuruxClient`
+
+```python
+SepuruxClient(base_url, api_key=None, project_id=None, timeout=30, sdk_header=None)
+```
+
+The SDK automatically sends `X-Sepurux-SDK: py/<version>` on requests.
+Use `sdk_header` only if you need to override it manually.
+
+Methods:
+- `upload_trace(trace: dict) -> str`
+- `create_campaign(name, mutation_set, eval_set, mutation_pack_id=None) -> str`
+- `start_run(trace_id, campaign_id, thresholds=None) -> str`
+- `get_run(run_id) -> dict`
+
+### `TraceBuilder`
+
+`TraceBuilder` outputs backend-compatible traces:
+
+```json
+{
+  "trace_version": "0.1",
+  "source": "sdk",
+  "task": {"name": "...", "input": {}},
+  "events": []
+}
+```
+
+### Recorder
+
+Use a context manager:
+
+```python
+from sepurux import sepurux_trace
+
+with sepurux_trace("task_name", {"input": "value"}) as rec:
+    rec.model_step("name", {"foo": "bar"}, output={"ok": True})
+    rec.tool_call("tool.name", {"arg": 1})
+    rec.tool_result("tool.name", {"result": "ok"})
+    rec.error(message="something happened", tool="tool.name")
+```
+
+### Decorator
+
+```python
+from sepurux import record_trace
+
+@record_trace(client=client, campaign_id="<campaign_id>")
+def run_business_logic(x: int) -> int:
+    return x * 2
+```
+
+The decorator preserves the function return value and attempts to upload/start runs in the background path without interrupting normal execution.
+
+## Example script
+
+See `examples/sdk_demo.py`.
+
+```bash
+python sdk/examples/sdk_demo.py
+```
+
+Optional environment variables:
+- `SEPURUX_API_BASE_URL` (default `http://localhost:8000`)
+- `SEPURUX_UI_BASE_URL` (default `http://localhost:3000`)
+- `SEPURUX_API_KEY`
+- `SEPURUX_PROJECT_ID`
+- `SEPURUX_CAMPAIGN_ID` (if provided, script starts a run)
+
+## Publish to PyPI (CI)
+
+This repository includes `.github/workflows/sdk-publish-pypi.yml` to publish the SDK directly to PyPI.
+
+Setup:
+- Add `PYPI_API_TOKEN` in GitHub repository secrets.
+- Ensure the package version in `sdk/pyproject.toml` is new.
+
+Release:
+- Push a tag like `sdk-v0.2.0` to trigger publish.
+- Or run the workflow manually from GitHub Actions.

sepurux-0.2.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sepurux"
+version = "0.2.0"
+description = "Python SDK for Sepurux trace recording and uploads"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+  { name = "Sepurux" }
+]
+dependencies = [
+  "httpx>=0.27,<1",
+]
+
+[project.urls]
+Homepage = "https://github.com/felixkwasisarpong/Sepurux"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sepurux*"]

sepurux-0.2.0/sepurux/__init__.py

@@ -0,0 +1,13 @@
+"""Sepurux Python SDK."""
+
+from .client import SepuruxClient
+from .recorder import TraceRecorder, record_trace, sepurux_trace
+from .trace import TraceBuilder
+
+__all__ = [
+    "SepuruxClient",
+    "TraceBuilder",
+    "TraceRecorder",
+    "sepurux_trace",
+    "record_trace",
+]

sepurux-0.2.0/sepurux/client.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+from typing import Any
+
+import httpx
+
+from .types import RunStatus, TracePayload
+
+SDK_PACKAGE_NAME = "sepurux"
+
+
+class SepuruxClient:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str | None = None,
+        project_id: str | None = None,
+        timeout: float = 30,
+        sdk_header: str | None = None,
+    ) -> None:
+        normalized = base_url.strip().rstrip("/")
+        if not normalized:
+            raise ValueError("base_url must be a non-empty URL")
+
+        self.base_url = normalized
+        self.api_key = api_key
+        self.project_id = project_id
+        self.timeout = timeout
+        self.sdk_header = (sdk_header or _default_sdk_header()).strip() or _default_sdk_header()
+
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            timeout=timeout,
+            headers={"Accept": "application/json", "X-Sepurux-SDK": self.sdk_header},
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def upload_trace(self, trace: dict[str, Any] | TracePayload) -> str:
+        if not isinstance(trace, dict):
+            raise TypeError("trace must be a dictionary")
+
+        response = self._client.post(
+            "/v1/traces",
+            headers=self._request_headers(),
+            json=trace,
+        )
+        response.raise_for_status()
+
+        payload = _parse_json_response(response)
+        trace_id = payload.get("trace_id")
+        if not isinstance(trace_id, str) or not trace_id:
+            raise ValueError("Trace upload succeeded but trace_id was missing")
+        return trace_id
+
+    def create_campaign(
+        self,
+        *,
+        name: str,
+        mutation_set: Any,
+        eval_set: Any,
+        mutation_pack_id: str | None = None,
+    ) -> str:
+        payload: dict[str, Any] = {
+            "name": name,
+            "mutation_set": mutation_set,
+            "eval_set": eval_set,
+        }
+        if mutation_pack_id:
+            payload["mutation_pack_id"] = mutation_pack_id
+
+        response = self._client.post(
+            "/v1/campaigns",
+            headers=self._request_headers(),
+            json=payload,
+        )
+        response.raise_for_status()
+
+        data = _parse_json_response(response)
+        campaign_id = data.get("campaign_id")
+        if not isinstance(campaign_id, str) or not campaign_id:
+            raise ValueError("Campaign creation succeeded but campaign_id was missing")
+        return campaign_id
+
+    def start_run(
+        self,
+        *,
+        trace_id: str,
+        campaign_id: str,
+        thresholds: dict[str, Any] | None = None,
+    ) -> str:
+        run_payload = {
+            "trace_id": trace_id,
+            "campaign_id": campaign_id,
+        }
+
+        # Prefer standard /v1/runs. If unavailable, fallback to CI endpoint.
+        response = self._client.post(
+            "/v1/runs",
+            headers=self._request_headers(),
+            json=run_payload,
+        )
+
+        if response.status_code in {404, 405}:
+            ci_payload: dict[str, Any] = {
+                "trace_id": trace_id,
+                "campaign_id": campaign_id,
+                "thresholds": thresholds
+                or {
+                    "min_pass_rate": 0.9,
+                    "max_unsafe": 0,
+                },
+            }
+            response = self._client.post(
+                "/v1/ci/runs",
+                headers=self._request_headers(),
+                json=ci_payload,
+            )
+
+        response.raise_for_status()
+        payload = _parse_json_response(response)
+        run_id = payload.get("run_id")
+        if not isinstance(run_id, str) or not run_id:
+            raise ValueError("Run creation succeeded but run_id was missing")
+        return run_id
+
+    def get_run(self, run_id: str) -> RunStatus:
+        response = self._client.get(
+            f"/v1/runs/{run_id}",
+            headers=self._request_headers(),
+        )
+        response.raise_for_status()
+
+        payload = _parse_json_response(response)
+        summary = payload.get("summary")
+        return {
+            "run_id": str(payload.get("run_id") or run_id),
+            "status": str(payload.get("status") or "unknown"),
+            "summary": summary if isinstance(summary, dict) else None,
+        }
+
+    def __enter__(self) -> SepuruxClient:
+        return self
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> None:
+        del exc_type, exc, tb
+        self.close()
+
+    def _request_headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {}
+        if self.api_key:
+            headers["X-API-Key"] = self.api_key
+        if self.project_id:
+            headers["X-Project-Id"] = self.project_id
+        headers["X-Sepurux-SDK"] = self.sdk_header
+        return headers
+
+
+def _parse_json_response(response: httpx.Response) -> dict[str, Any]:
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ValueError("Expected JSON object response")
+    return data
+
+
+def _default_sdk_header() -> str:
+    try:
+        sdk_version = version(SDK_PACKAGE_NAME)
+    except PackageNotFoundError:
+        sdk_version = "dev"
+    return f"py/{sdk_version}"

sepurux-0.2.0/sepurux/recorder.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import functools
+import inspect
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any, ParamSpec, TypeVar
+
+from .trace import TraceBuilder
+from .types import TracePayload
+
+if TYPE_CHECKING:
+    from .client import SepuruxClient
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class TraceRecorder:
+    """Friendly recorder wrapper around TraceBuilder."""
+
+    def __init__(
+        self,
+        task_name: str,
+        task_input: dict[str, Any] | None = None,
+    ) -> None:
+        self._builder = TraceBuilder(task_name=task_name, task_input=task_input)
+
+    def model_step(self, name: str, input: Any, output: Any | None = None) -> None:
+        self._builder.add_model_step(name=name, input=input, output=output)
+
+    def tool_call(self, tool: str, args: dict[str, Any]) -> None:
+        self._builder.add_tool_call(tool=tool, args=args)
+
+    def tool_result(self, tool: str, result: Any) -> None:
+        self._builder.add_tool_result(tool=tool, result=result)
+
+    def error(self, tool: str | None = None, message: str = "") -> None:
+        self._builder.add_error(message=message, tool=tool)
+
+    def to_trace(self) -> TracePayload:
+        return self._builder.to_trace()
+
+
+@contextmanager
+def sepurux_trace(
+    task_name: str,
+    task_input: dict[str, Any] | None = None,
+) -> Iterator[TraceRecorder]:
+    recorder = TraceRecorder(task_name=task_name, task_input=task_input)
+    yield recorder
+
+
+def record_trace(
+    *,
+    client: SepuruxClient,
+    campaign_id: str | None = None,
+    task_name: str | None = None,
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """Decorator that records function traces and optionally starts a run."""
+
+    def decorator(func: Callable[P, R]) -> Callable[P, R]:
+        @functools.wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            trace_task_name = task_name or func.__name__
+            task_input = {
+                "function": func.__name__,
+                "args": _safe_json_value(list(args)),
+                "kwargs": _safe_json_value(dict(kwargs)),
+            }
+
+            with sepurux_trace(trace_task_name, task_input=task_input) as recorder:
+                recorder.model_step(
+                    "function.call",
+                    {"qualname": getattr(func, "__qualname__", func.__name__)},
+                )
+                try:
+                    result = func(*args, **kwargs)
+                except Exception as exc:
+                    recorder.error(tool=func.__name__, message=str(exc))
+                    raise
+                recorder.model_step(
+                    "function.return", {"ok": True}, output=_safe_json_value(result)
+                )
+
+                trace = recorder.to_trace()
+
+            # SDK telemetry should not break business logic.
+            try:
+                trace_id = client.upload_trace(trace)
+                if campaign_id:
+                    client.start_run(trace_id=trace_id, campaign_id=campaign_id)
+            except Exception:
+                pass
+
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def _safe_json_value(value: Any) -> Any:
+    if value is None or isinstance(value, str | int | float | bool):
+        return value
+    if isinstance(value, dict):
+        return {str(k): _safe_json_value(v) for k, v in value.items()}
+    if isinstance(value, list | tuple | set):
+        return [_safe_json_value(v) for v in value]
+
+    if inspect.isfunction(value) or inspect.ismethod(value):
+        return getattr(value, "__name__", "callable")
+
+    return repr(value)

sepurux-0.2.0/sepurux/trace.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from .types import TraceEvent, TracePayload
+
+
+class TraceBuilder:
+    """Builds Sepurux trace payloads in the backend-compatible schema."""
+
+    def __init__(
+        self,
+        task_name: str,
+        task_input: dict[str, Any] | None = None,
+        *,
+        source: str = "sdk",
+        trace_version: str = "0.1",
+    ) -> None:
+        if not task_name.strip():
+            raise ValueError("task_name must be a non-empty string")
+        if not source.strip():
+            raise ValueError("source must be a non-empty string")
+        if not trace_version.strip():
+            raise ValueError("trace_version must be a non-empty string")
+
+        self._trace_version = trace_version
+        self._source = source
+        self._task_name = task_name
+        self._task_input = task_input or {}
+        self._events: list[TraceEvent] = []
+
+    def add_model_step(
+        self,
+        name: str,
+        input: Any,
+        output: Any | None = None,
+    ) -> TraceBuilder:
+        event: TraceEvent = {
+            "type": "model_step",
+            "timestamp": _utc_now_iso(),
+            "name": name,
+            "input": input,
+        }
+        if output is not None:
+            event["output"] = output
+        self._events.append(event)
+        return self
+
+    def add_tool_call(self, tool: str, args: dict[str, Any]) -> TraceBuilder:
+        event: TraceEvent = {
+            "type": "tool_call",
+            "timestamp": _utc_now_iso(),
+            "tool": tool,
+            "args": args,
+        }
+        self._events.append(event)
+        return self
+
+    def add_tool_result(self, tool: str, result: Any) -> TraceBuilder:
+        event: TraceEvent = {
+            "type": "tool_result",
+            "timestamp": _utc_now_iso(),
+            "tool": tool,
+            "result": result,
+        }
+        self._events.append(event)
+        return self
+
+    def add_error(self, message: str, tool: str | None = None) -> TraceBuilder:
+        event: TraceEvent = {
+            "type": "error",
+            "timestamp": _utc_now_iso(),
+            "message": message,
+        }
+        if tool:
+            event["tool"] = tool
+        self._events.append(event)
+        return self
+
+    def to_trace(self) -> TracePayload:
+        return {
+            "trace_version": self._trace_version,
+            "source": self._source,
+            "task": {
+                "name": self._task_name,
+                "input": self._task_input,
+            },
+            "events": list(self._events),
+        }
+
+
+def _utc_now_iso() -> str:
+    return datetime.now(UTC).isoformat()

sepurux-0.2.0/sepurux/types.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any, TypedDict
+
+
+class TaskPayload(TypedDict):
+    name: str
+    input: dict[str, Any]
+
+
+TraceEvent = dict[str, Any]
+
+
+class TracePayload(TypedDict):
+    trace_version: str
+    source: str
+    task: TaskPayload
+    events: list[TraceEvent]
+
+
+class RunStatus(TypedDict, total=False):
+    run_id: str
+    status: str
+    summary: dict[str, Any] | None

sepurux-0.2.0/sepurux.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: sepurux
+Version: 0.2.0
+Summary: Python SDK for Sepurux trace recording and uploads
+Author: Sepurux
+License: MIT
+Project-URL: Homepage, https://github.com/felixkwasisarpong/Sepurux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1,>=0.27
+
+# Sepurux Python SDK
+
+Python SDK for recording Sepurux traces and uploading them to a Sepurux API.
+
+## Install
+
+```bash
+pip install -e sdk
+```
+
+## Quick start
+
+```python
+from sepurux import SepuruxClient, sepurux_trace
+
+client = SepuruxClient(
+    base_url="http://localhost:8000",
+    api_key="sepurux-dev-key",
+    project_id="22222222-2222-2222-2222-222222222222",
+)
+
+with sepurux_trace("example_task", {"user_id": "u-123"}) as rec:
+    rec.model_step("plan", {"goal": "create issue"}, output={"ok": True})
+    rec.tool_call("jira.create_issue(commit)", {"summary": "SDK test"})
+    rec.tool_result("jira.create_issue(commit)", {"issue_id": "OPS-123"})
+
+trace_id = client.upload_trace(rec.to_trace())
+print("trace_id:", trace_id)
+```
+
+## API
+
+### `SepuruxClient`
+
+```python
+SepuruxClient(base_url, api_key=None, project_id=None, timeout=30, sdk_header=None)
+```
+
+The SDK automatically sends `X-Sepurux-SDK: py/<version>` on requests.
+Use `sdk_header` only if you need to override it manually.
+
+Methods:
+- `upload_trace(trace: dict) -> str`
+- `create_campaign(name, mutation_set, eval_set, mutation_pack_id=None) -> str`
+- `start_run(trace_id, campaign_id, thresholds=None) -> str`
+- `get_run(run_id) -> dict`
+
+### `TraceBuilder`
+
+`TraceBuilder` outputs backend-compatible traces:
+
+```json
+{
+  "trace_version": "0.1",
+  "source": "sdk",
+  "task": {"name": "...", "input": {}},
+  "events": []
+}
+```
+
+### Recorder
+
+Use a context manager:
+
+```python
+from sepurux import sepurux_trace
+
+with sepurux_trace("task_name", {"input": "value"}) as rec:
+    rec.model_step("name", {"foo": "bar"}, output={"ok": True})
+    rec.tool_call("tool.name", {"arg": 1})
+    rec.tool_result("tool.name", {"result": "ok"})
+    rec.error(message="something happened", tool="tool.name")
+```
+
+### Decorator
+
+```python
+from sepurux import record_trace
+
+@record_trace(client=client, campaign_id="<campaign_id>")
+def run_business_logic(x: int) -> int:
+    return x * 2
+```
+
+The decorator preserves the function return value and attempts to upload/start runs in the background path without interrupting normal execution.
+
+## Example script
+
+See `examples/sdk_demo.py`.
+
+```bash
+python sdk/examples/sdk_demo.py
+```
+
+Optional environment variables:
+- `SEPURUX_API_BASE_URL` (default `http://localhost:8000`)
+- `SEPURUX_UI_BASE_URL` (default `http://localhost:3000`)
+- `SEPURUX_API_KEY`
+- `SEPURUX_PROJECT_ID`
+- `SEPURUX_CAMPAIGN_ID` (if provided, script starts a run)
+
+## Publish to PyPI (CI)
+
+This repository includes `.github/workflows/sdk-publish-pypi.yml` to publish the SDK directly to PyPI.
+
+Setup:
+- Add `PYPI_API_TOKEN` in GitHub repository secrets.
+- Ensure the package version in `sdk/pyproject.toml` is new.
+
+Release:
+- Push a tag like `sdk-v0.2.0` to trigger publish.
+- Or run the workflow manually from GitHub Actions.

sepurux-0.2.0/sepurux.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+sepurux/__init__.py
+sepurux/client.py
+sepurux/recorder.py
+sepurux/trace.py
+sepurux/types.py
+sepurux.egg-info/PKG-INFO
+sepurux.egg-info/SOURCES.txt
+sepurux.egg-info/dependency_links.txt
+sepurux.egg-info/requires.txt
+sepurux.egg-info/top_level.txt
+tests/test_client.py
+tests/test_trace_builder.py

sepurux-0.2.0/sepurux.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sepurux-0.2.0/sepurux.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx<1,>=0.27

sepurux-0.2.0/sepurux.egg-info/top_level.txt

@@ -0,0 +1 @@
+sepurux

sepurux-0.2.0/setup.cfg

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

sepurux-0.2.0/tests/test_client.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import httpx
+from sepurux import SepuruxClient
+
+
+class _RequestCapture:
+    def __init__(self) -> None:
+        self.requests: list[httpx.Request] = []
+
+    def __call__(self, request: httpx.Request) -> httpx.Response:
+        self.requests.append(request)
+        if request.url.path == "/v1/traces":
+            return httpx.Response(201, json={"trace_id": "trace-123"})
+        return httpx.Response(404, json={"detail": "not found"})
+
+
+def test_upload_trace_uses_traces_endpoint_and_headers() -> None:
+    capture = _RequestCapture()
+    transport = httpx.MockTransport(capture)
+
+    client = SepuruxClient(
+        base_url="http://localhost:8000",
+        api_key="key-1",
+        project_id="project-1",
+    )
+    client._client = httpx.Client(
+        base_url=client.base_url,
+        transport=transport,
+        timeout=30,
+        headers={"Accept": "application/json", "X-Sepurux-SDK": client.sdk_header},
+    )
+
+    trace_id = client.upload_trace(
+        {
+            "trace_version": "0.1",
+            "source": "sdk",
+            "task": {"name": "task", "input": {}},
+            "events": [],
+        }
+    )
+
+    assert trace_id == "trace-123"
+    assert len(capture.requests) == 1
+    request = capture.requests[0]
+    assert request.url.path == "/v1/traces"
+    assert request.headers.get("X-API-Key") == "key-1"
+    assert request.headers.get("X-Project-Id") == "project-1"
+    assert request.headers.get("X-Sepurux-SDK", "").startswith("py/")
+
+
+def test_upload_trace_uses_explicit_sdk_header_override() -> None:
+    capture = _RequestCapture()
+    transport = httpx.MockTransport(capture)
+
+    client = SepuruxClient(
+        base_url="http://localhost:8000",
+        api_key="key-1",
+        project_id="project-1",
+        sdk_header="py/9.9.9",
+    )
+    client._client = httpx.Client(
+        base_url=client.base_url,
+        transport=transport,
+        timeout=30,
+        headers={"Accept": "application/json", "X-Sepurux-SDK": client.sdk_header},
+    )
+
+    trace_id = client.upload_trace(
+        {
+            "trace_version": "0.1",
+            "source": "sdk",
+            "task": {"name": "task", "input": {}},
+            "events": [],
+        }
+    )
+
+    assert trace_id == "trace-123"
+    assert len(capture.requests) == 1
+    request = capture.requests[0]
+    assert request.headers.get("X-Sepurux-SDK") == "py/9.9.9"

sepurux-0.2.0/tests/test_trace_builder.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from sepurux import TraceBuilder
+
+
+def test_trace_builder_schema_shape() -> None:
+    builder = TraceBuilder("demo_task", {"prompt": "hello"})
+    builder.add_model_step("plan", {"goal": "create issue"}, output={"ok": True})
+    builder.add_tool_call("jira.create_issue(commit)", {"summary": "test"})
+    builder.add_tool_result("jira.create_issue(commit)", {"issue_id": "OPS-123"})
+
+    trace = builder.to_trace()
+
+    assert trace["trace_version"] == "0.1"
+    assert trace["source"] == "sdk"
+    assert trace["task"] == {"name": "demo_task", "input": {"prompt": "hello"}}
+    assert len(trace["events"]) == 3
+    assert trace["events"][0]["type"] == "model_step"
+    assert trace["events"][1]["type"] == "tool_call"
+    assert trace["events"][2]["type"] == "tool_result"