trodo-python 2.26.2__tar.gz → 3.0.1__tar.gz

{trodo_python-2.26.2 → trodo_python-3.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 2.26.2
+Version: 3.0.1
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side

{trodo_python-2.26.2 → trodo_python-3.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trodo-python"
-version = "2.26.2"
+version = "3.0.1"
 description = "Trodo Analytics SDK for Python — server-side event tracking"
 readme = "README.md"
 license = { text = "ISC" }

{trodo_python-2.26.2 → trodo_python-3.0.1}/tests/test_datasets.py

@@ -144,3 +144,85 @@ def test_append_accepts_unit_references_without_input():
         {"conversation_id": "c1", "metadata": {"k": 1}},
         {"eval_run_id": "v1"},
     ]
+
+
+# ---------------------------------------------------------------------------
+# Management with an API key (the team API the CLI uses)
+# ---------------------------------------------------------------------------
+
+class FakeApi:
+    """Records every call to the team API; datasets are looked up by name."""
+
+    def __init__(self):
+        self.calls = []
+
+    def get(self, path, params=None):
+        self.calls.append(("GET", path, params))
+        if path == "/datasets":
+            return {"datasets": [{"id": "d1", "name": "Refunds"}]}
+        return {"dataset": {"id": "d1", "name": "Refunds", "columns": ["q"]}}
+
+    def post(self, path, body=None):
+        self.calls.append(("POST", path, body))
+        if path == "/datasets":
+            return {"dataset": {"id": "d2", "name": body["name"]}}
+        if path.endswith("/items/update"):
+            return {"updated": len(body["updates"]), "unchanged": 0, "missing": [], "version": 4}
+        if path.endswith("/items/archive"):
+            return {"archived": len(body["ids"]), "unchanged": 0, "version": 5}
+        if path.endswith("/items/restore"):
+            return {"restored": len(body["ids"]), "unchanged": 0, "version": 6}
+        if path.endswith("/columns/add"):
+            return {"added": 1, "columns": ["q", "lang"], "derived_columns": []}
+        return {"written": len(body.get("items", []))}
+
+    def lines(self, path, params=None):
+        self.calls.append(("LINES", path, params))
+        return iter([{"id": "i1", "input": {"query": "hi"}}])
+
+
+def test_create_with_rows_sends_expected_as_expected_output():
+    api = FakeApi()
+    out = DatasetManager(None, api).create("New", items=[{"input": "2+2?", "expected": {"answer": 4}}])
+    assert out == {"dataset": {"id": "d2", "name": "New"}, "written": 1}
+    assert api.calls[-1] == ("POST", "/datasets/d2/items", {"items": [{"input": "2+2?", "expected_output": {"answer": 4}}]})
+
+
+def test_update_resolves_the_name_and_sends_one_call():
+    api = FakeApi()
+    out = DatasetManager(None, api).update("refunds", [{"id": "i1", "input": "redacted"}, {"no": "id"}], label="derived", version_name="pii")
+    assert out == {"updated": 1, "unchanged": 0, "missing": [], "version": 4}
+    assert api.calls[-1] == ("POST", "/datasets/d1/items/update", {"updates": [{"id": "i1", "input": "redacted"}], "label": "derived", "version_name": "pii"})
+
+
+def test_archive_restore_and_columns():
+    api = FakeApi()
+    mgr = DatasetManager(None, api)
+    assert mgr.archive("Refunds", ["i1", "i2"])["archived"] == 2
+    assert mgr.restore("Refunds", ["i1"])["restored"] == 1
+    assert mgr.add_columns("Refunds", ["lang"])["added"] == 1
+    assert [c[1] for c in api.calls if c[0] == "POST"] == ["/datasets/d1/items/archive", "/datasets/d1/items/restore", "/datasets/d1/columns/add"]
+
+
+def test_rows_streams_the_export_with_its_filters():
+    api = FakeApi()
+    rows = list(DatasetManager(None, api).rows("Refunds", rows="failed", format="openai"))
+    assert rows[0]["id"] == "i1"
+    assert api.calls[-1] == ("LINES", "/datasets/d1/export", {"rows": "failed", "eval": None, "format": "openai", "target": None, "version": None})
+
+
+def test_an_unknown_dataset_and_missing_ids_are_errors():
+    mgr = DatasetManager(None, FakeApi())
+    with pytest.raises(ValueError, match="no dataset"):
+        mgr.update("Nope", [{"id": "i1"}])
+    with pytest.raises(ValueError, match="row ids"):
+        mgr.archive("Refunds", [])
+
+
+def test_management_needs_an_api_key(monkeypatch):
+    from trodo.api.management import ManagementClient
+    monkeypatch.delenv("TRODO_API_KEY", raising=False)
+    with pytest.raises(ValueError, match="TRODO_API_KEY"):
+        ManagementClient()
+    c = ManagementClient(api_key="trodo_mk_x", api_url="http://localhost:8002/")
+    assert c.base == "http://localhost:8002/api/v1"

trodo_python-3.0.1/tests/test_long_runs.py

@@ -0,0 +1,34 @@
+"""A run with more spans than one buffer holds keeps every span (it used to
+drop everything after the 1,000th) and its totals still count all of them."""
+from __future__ import annotations
+
+from trodo.otel.processor import TrodoRun, TrodoSpan, TrodoSpanProcessor
+from trodo.otel.wrap_agent import _aggregate
+
+
+def span(i, run="r1"):
+    return TrodoSpan(span_id=f"s{i}", run_id=run, parent_span_id=None, kind="tool" if i % 2 else "llm",
+                     name="step", status="error" if i == 4 else "ok", input_tokens=10, output_tokens=1)
+
+
+def test_a_full_buffer_is_sent_ahead_and_nothing_is_dropped(http):
+    p = TrodoSpanProcessor(http, max_spans_per_run=3)
+    for i in range(8):
+        p.enqueue_span(span(i))
+    # Two full chunks went ahead through append; two spans wait for the run.
+    assert [(rid, [s["span_id"] for s in spans]) for rid, spans in http.spans_append] == [
+        ("r1", ["s0", "s1", "s2"]), ("r1", ["s3", "s4", "s5"])]
+    agg = _aggregate(p.get_pending("r1"))
+    assert agg["span_count"] == 8 and agg["total_tokens_in"] == 80 and agg["tool_count"] == 4 and agg["error_count"] == 1
+    p.ingest_run(TrodoRun(run_id="r1", agent_name="deep", **{k: v for k, v in agg.items() if k in ("span_count", "tool_count", "error_count")}))
+    sent = [s["span_id"] for _, spans in http.spans_append for s in spans] + [s["span_id"] for s in http.run_ingest[-1]["spans"]]
+    assert sorted(sent) == sorted(f"s{i}" for i in range(8))
+    assert len(sent) == len(set(sent)), "no span is sent twice"
+    assert p.get_pending("r1") == []
+
+
+def test_runs_do_not_share_buffers(http):
+    p = TrodoSpanProcessor(http, max_spans_per_run=2)
+    p.enqueue_span(span(1, "a")); p.enqueue_span(span(2, "b")); p.enqueue_span(span(3, "a"))
+    assert [rid for rid, _ in http.spans_append] == ["a"]
+    assert len(p.get_pending("b")) == 1

{trodo_python-2.26.2 → trodo_python-3.0.1}/trodo/__init__.py

@@ -120,15 +120,10 @@ __all__ = [
     "TemplateError",
     "ManagedPrompt",
     "PromptSummary",
-    # Datasets & experiments
+    # Datasets
+    "datasets",
     "append_dataset",
     "export_dataset",
-    "ingest_experiment",
-    "create_experiment",
-    "run_experiment",
-    "get_experiment",
-    "wait_experiment",
-    "compare_experiments",
 ]
 
 # ============================================================================
@@ -412,9 +407,30 @@ def render_template(
 
 
 # ----------------------------------------------------------------------------
-# Datasets & experiments ingest
+# Datasets
 # ----------------------------------------------------------------------------
 
+def datasets(api_key: Optional[str] = None, api_url: Optional[str] = None) -> Any:
+    """The team's datasets, managed with a Trodo API key (``TRODO_API_KEY``), as the CLI does::
+
+        ds = trodo.datasets()
+        ds.create("refund regressions", items=[{"input": "Refund order 42?", "expected": {"refund": True}}])
+        for row in ds.rows("refund regressions", rows="failed"):
+            ...
+        ds.update("refund regressions", [{"id": row["id"], "expected": "…"}])
+        ds.archive("refund regressions", [dup_id])      # restore() brings it back
+        ds.add_columns("refund regressions", ["lang"])
+
+    Works without ``trodo.init``; after it, ``append`` (site id) works here too.
+    Nothing deletes.
+    """
+    from .managers.dataset_manager import DatasetManager
+    from .api.management import ManagementClient
+    if api_key is None and api_url is None and _client is not None:
+        return _client.datasets
+    return DatasetManager(_client._http if _client is not None else None, ManagementClient(api_key, api_url))
+
+
 def append_dataset(
     ref: str,
     items: Union[Dict[str, Any], List[Dict[str, Any]]],
@@ -460,87 +476,6 @@ def export_dataset(
     )
 
 
-def ingest_experiment(
-    dataset: str,
-    outputs: List[Dict[str, Any]],
-    name: Optional[str] = None,
-    task_name: Optional[str] = None,
-    judge: Optional[Dict[str, Any]] = None,
-    evaluator_ids: Optional[List[str]] = None,
-    dataset_version_no: Optional[int] = None,
-) -> Dict[str, Any]:
-    """Ingest a batch of model *outputs* for *dataset* and grade them.
-
-    *outputs* is a list of dicts shaped ``{"item_position": int, "output": str,
-    "expected_output"?, "query"?, "context"?, "cost_usd"?, "latency_ms"?}``.
-    Configure grading with ``judge`` (``{"credential_id", "provider", "model"}``)
-    and/or ``evaluator_ids``::
-
-        exp = trodo.ingest_experiment("support-eval", [
-            {"item_position": 0, "output": "here is your tracking link"},
-        ], judge={"credential_id": "cred_1", "provider": "openai", "model": "gpt-4o"})
-
-    Returns the experiment dict.
-    """
-    return _get_client().experiments.ingest(
-        dataset,
-        outputs,
-        name=name,
-        task_name=task_name,
-        judge=judge,
-        evaluator_ids=evaluator_ids,
-        dataset_version_no=dataset_version_no,
-    )
-
-
-def create_experiment(
-    *,
-    dataset: Optional[str] = None,
-    dataset_id: Optional[str] = None,
-    models: List[Dict[str, Any]],
-    **kwargs: Any,
-) -> Dict[str, Any]:
-    """Create an experiment (immutable refs, status pending)."""
-    return _get_client().experiments.create(
-        dataset=dataset, dataset_id=dataset_id, models=models, **kwargs
-    )
-
-
-def run_experiment(
-    *,
-    dataset: Optional[str] = None,
-    dataset_id: Optional[str] = None,
-    models: List[Dict[str, Any]],
-    **kwargs: Any,
-) -> Dict[str, Any]:
-    """Create and run an experiment synchronously."""
-    return _get_client().experiments.run(
-        dataset=dataset, dataset_id=dataset_id, models=models, **kwargs
-    )
-
-
-def get_experiment(experiment_id: str) -> Dict[str, Any]:
-    """Fetch an experiment by id."""
-    return _get_client().experiments.get(experiment_id)
-
-
-def wait_experiment(
-    experiment_id: str,
-    *,
-    interval_ms: int = 2500,
-    timeout_ms: int = 600_000,
-) -> Dict[str, Any]:
-    """Poll until the experiment completes or fails."""
-    return _get_client().experiments.wait(
-        experiment_id, interval_ms=interval_ms, timeout_ms=timeout_ms
-    )
-
-
-def compare_experiments(a_id: str, b_id: str, *, strict: bool = False) -> Dict[str, Any]:
-    """Compare two experiments side by side."""
-    return _get_client().experiments.compare(a_id, b_id, strict=strict)
-
-
 def enable_auto_events() -> None:
     _get_client().enable_auto_events()
 

trodo_python-3.0.1/trodo/_version.py

@@ -0,0 +1 @@
+SDK_VERSION = "3.0.1"

{trodo_python-2.26.2 → trodo_python-3.0.1}/trodo/api/endpoints.py

@@ -28,10 +28,5 @@ RUNS_START = "/api/sdk/runs/start"
 RUNS_BASE = "/api/sdk/runs"  # /runs/{run_id}/end, /spans, /feedback
 SPANS_APPEND = "/api/sdk/spans/append"
 OTLP_TRACES = "/api/sdk/otel/v1/traces"
-# Datasets & experiments
+# Datasets
 DATASETS_BASE = "/api/sdk/datasets"  # /datasets/{ref}/items
-EXPERIMENTS = "/api/sdk/experiments"
-EXPERIMENTS_INGEST = "/api/sdk/experiments/ingest"
-EXPERIMENTS_CREATE = "/api/sdk/experiments/create"
-EXPERIMENTS_RUN = "/api/sdk/experiments/run"
-EXPERIMENTS_COMPARE = "/api/sdk/experiments/compare"

{trodo_python-2.26.2 → trodo_python-3.0.1}/trodo/api/http_client.py

@@ -219,31 +219,6 @@ class HttpClient:
             "version": int(version) if version and version.isdigit() else None,
         }
 
-    def ingest_experiment(self, body: Dict[str, Any]) -> ApiResult:
-        return self._request("/api/sdk/experiments/ingest", body)
-
-    def create_experiment(self, body: Dict[str, Any]) -> ApiResult:
-        return self._request("/api/sdk/experiments/create", body)
-
-    def run_experiment(self, body: Dict[str, Any]) -> ApiResult:
-        return self._request("/api/sdk/experiments/run", body)
-
-    def run_experiment_by_id(self, experiment_id: str) -> ApiResult:
-        from urllib.parse import quote
-        return self._request(f"/api/sdk/experiments/{quote(str(experiment_id), safe='')}/run", {})
-
-    def get_experiment(self, experiment_id: str) -> ApiResult:
-        from urllib.parse import quote
-        return self._get(f"/api/sdk/experiments/{quote(str(experiment_id), safe='')}")
-
-    def compare_experiments(
-        self, a_id: str, b_id: str, strict: bool = False
-    ) -> ApiResult:
-        params: Dict[str, Any] = {"a": a_id, "b": b_id}
-        if strict:
-            params["strict"] = "true"
-        return self._get("/api/sdk/experiments/compare", params)
-
     def post_track(self, session_data: Dict[str, Any]) -> ApiResult:
         return self._request("/api/sdk/track", {"sessionData": session_data})
 

trodo_python-3.0.1/trodo/api/management.py

@@ -0,0 +1,90 @@
+"""The team API (/api/v1) with a Trodo API key — what the CLI uses.
+
+Dataset management (create, read rows, edit, archive, add columns) goes
+through here, never through the site id: a site id can sit in a browser page,
+and nobody who only has that should be able to change a dataset. The key is a
+Trodo API key (Settings → MCP, or ``trodo login``), passed in or read from
+``TRODO_API_KEY``; ``TRODO_API_URL`` overrides the address.
+
+Reads retry on network errors and 502/503/504; writes are sent once.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from typing import Any, Dict, Iterator, Optional
+
+import requests
+
+from .._version import SDK_VERSION
+
+DEFAULT_API_URL = "https://api.trodo.ai"
+
+
+class TrodoApiError(RuntimeError):
+    """The API refused or failed. ``status`` and ``body`` say why."""
+
+    def __init__(self, message: str, status: Optional[int] = None, body: Any = None) -> None:
+        super().__init__(message)
+        self.status = status
+        self.body = body
+
+
+class ManagementClient:
+    def __init__(self, api_key: Optional[str] = None, api_url: Optional[str] = None, timeout: int = 60) -> None:
+        key = api_key or os.environ.get("TRODO_API_KEY")
+        if not key:
+            raise ValueError(
+                "trodo: dataset management needs a Trodo API key: pass api_key= or set TRODO_API_KEY "
+                "(Settings → MCP, or `trodo login`). The site id cannot change datasets."
+            )
+        self.base = (api_url or os.environ.get("TRODO_API_URL") or DEFAULT_API_URL).rstrip("/") + "/api/v1"
+        self.timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+            "User-Agent": f"trodo-python/{SDK_VERSION}",
+        })
+
+    def _send(self, method: str, path: str, *, params: Optional[Dict[str, Any]] = None,
+              body: Any = None, stream: bool = False) -> requests.Response:
+        url = self.base + path
+        clean = {k: v for k, v in (params or {}).items() if v is not None and v != ""}
+        tries = 4 if method == "GET" else 1
+        for attempt in range(tries):
+            try:
+                resp = self._session.request(method, url, params=clean, data=None if body is None else json.dumps(body),
+                                             timeout=self.timeout, stream=stream)
+            except requests.RequestException as exc:
+                if attempt + 1 < tries:
+                    time.sleep(0.5 * (2 ** attempt))
+                    continue
+                raise TrodoApiError(f"trodo: {method} {path} failed: {exc}") from exc
+            if resp.status_code in (502, 503, 504) and attempt + 1 < tries:
+                time.sleep(0.5 * (2 ** attempt))
+                continue
+            if resp.status_code >= 400:
+                try:
+                    data = resp.json()
+                except ValueError:
+                    data = {"message": resp.text[:300]}
+                msg = (data.get("message") or data.get("error")) if isinstance(data, dict) else None
+                raise TrodoApiError(f"trodo: {method} {path} → HTTP {resp.status_code} {msg or ''}".strip(), resp.status_code, data)
+            return resp
+        raise TrodoApiError(f"trodo: {method} {path} failed")  # pragma: no cover
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        return self._send("GET", path, params=params).json()
+
+    def post(self, path: str, body: Any = None) -> Any:
+        return self._send("POST", path, body=body if body is not None else {}).json()
+
+    def lines(self, path: str, params: Optional[Dict[str, Any]] = None) -> Iterator[Dict[str, Any]]:
+        """A JSON Lines response, one object at a time."""
+        resp = self._send("GET", path, params=params, stream=True)
+        for raw in resp.iter_lines(decode_unicode=True):
+            if raw and raw.strip():
+                yield json.loads(raw)

{trodo_python-2.26.2 → trodo_python-3.0.1}/trodo/client.py

@@ -84,7 +84,6 @@ class TrodoClient:
         self._session_manager = SessionManager(max_cached_users)
         self._prompts = None  # lazily-built PromptManager
         self._datasets = None  # lazily-built DatasetManager
-        self._experiments = None  # lazily-built ExperimentManager
         self._users = None  # lazily-built UserManager
 
         if batch_enabled:
@@ -149,14 +148,6 @@ class TrodoClient:
             self._datasets = DatasetManager(self._http)
         return self._datasets
 
-    @property
-    def experiments(self):
-        """Managed experiment runs + external ingest for server-side grading."""
-        if self._experiments is None:
-            from .managers.experiment_manager import ExperimentManager
-            self._experiments = ExperimentManager(self._http)
-        return self._experiments
-
     @property
     def users(self):
         """Create-or-update a user and their traits — the stateless-backend