trodo-python 2.16.0__py3-none-any.whl → 2.18.0__py3-none-any.whl

trodo/__init__.py

@@ -41,7 +41,7 @@ Downstream microservice (join the caller's run instead of making a new one):
 
 from __future__ import annotations
 
-__version__ = "2.16.0"
+__version__ = "2.18.0"
 
 from typing import Any, Callable, Dict, List, Optional, Union
 
@@ -80,6 +80,7 @@ __all__ = [
     "for_user",
     "track",
     "identify",
+    "upsert_user",
     "people_set",
     "people_set_once",
     "wallet_address",
@@ -119,9 +120,14 @@ __all__ = [
     "TemplateError",
     "ManagedPrompt",
     "PromptSummary",
-    # Datasets & experiments ingest
+    # Datasets & experiments
     "append_dataset",
     "ingest_experiment",
+    "create_experiment",
+    "run_experiment",
+    "get_experiment",
+    "wait_experiment",
+    "compare_experiments",
 ]
 
 # ============================================================================
@@ -251,6 +257,44 @@ def identify(identify_id: str, session_id: Optional[str] = None) -> UserContext:
     return _get_client().identify(identify_id, session_id)
 
 
+def upsert_user(
+    distinct_id: str,
+    *,
+    properties: Optional[Dict[str, Any]] = None,
+    set_once: Optional[Dict[str, Any]] = None,
+    fixed_properties: Optional[Dict[str, Any]] = None,
+):
+    """Create-or-update a user and their traits in one idempotent call.
+
+    The stateless-backend primitive: a request handler knows who the user is and
+    a few things about them for the duration of one request, and this is how you
+    say so. Safe to call on every request.
+
+        trodo.upsert_user(
+            "user-42",
+            properties={"plan": "pro"},
+            set_once={"signup_date": "2026-01-04"},
+            fixed_properties={"last_location_country": "India"},
+        )
+
+    Every bag is optional — with none of them it still ensures the user exists,
+    which is useful at signup, before they have produced any agent runs.
+
+    ``fixed_properties`` writes the real profile columns the dashboard filters
+    on, limited to what a backend can honestly know (country, city). Device,
+    browser, OS, referrer and UTM are browser observations and come back in
+    ``skipped`` instead of being stored.
+
+    Mirrors ``trodo.users.upsert(...)`` in trodo-node.
+    """
+    return _get_client().upsert_user(
+        distinct_id,
+        properties=properties,
+        set_once=set_once,
+        fixed_properties=fixed_properties,
+    )
+
+
 def people_set(distinct_id: str, properties: Dict[str, Any]):
     """Set profile properties for a user — module-level convenience mirroring
     ``trodo.people.set(distinctId, props)`` in trodo-node. Equivalent to
@@ -405,6 +449,54 @@ def ingest_experiment(
     )
 
 
+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/api/endpoints.py

@@ -4,6 +4,8 @@ EVENTS_BULK = "/api/events/bulk"
 IDENTIFY = "/api/sdk/identify"
 WALLET_ADDRESS = "/api/sdk/wallet-address"
 RESET = "/api/sdk/reset"
+# Identity + traits in one idempotent call.
+USERS_UPSERT = "/api/sdk/users/upsert"
 PEOPLE_SET = "/api/sdk/people/set"
 PEOPLE_SET_ONCE = "/api/sdk/people/set_once"
 PEOPLE_UNSET = "/api/sdk/people/unset"
@@ -23,6 +25,10 @@ RUNS_INGEST = "/api/sdk/runs/ingest"
 RUNS_START = "/api/sdk/runs/start"
 RUNS_BASE = "/api/sdk/runs"  # /runs/{run_id}/end, /spans, /feedback
 OTLP_TRACES = "/api/sdk/otel/v1/traces"
-# Datasets & experiments ingest
+# Datasets & experiments
 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/api/http_client.py

@@ -9,6 +9,7 @@ from typing import Any, Callable, Dict, Optional
 import requests
 
 from ..types import ApiResult, EventPayload
+from . import endpoints
 
 
 class HttpClient:
@@ -143,6 +144,28 @@ class HttpClient:
     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})
 
@@ -161,6 +184,17 @@ class HttpClient:
     def post_reset(self, payload: Dict[str, Any]) -> ApiResult:
         return self._request("/api/sdk/reset", payload)
 
+    def post_user_upsert(self, payload: Dict[str, Any]) -> ApiResult:
+        """Create-or-update a user and their traits.
+
+        Degrades gracefully against a backend that predates the endpoint:
+        ``_request`` never raises, so a 404 surfaces through ``on_error`` and
+        returns an empty result rather than breaking the caller's request
+        handler. Users on an older backend lose the trait write, not their
+        application.
+        """
+        return self._request(endpoints.USERS_UPSERT, payload)
+
     def post_people(self, path: str, payload: Dict[str, Any]) -> ApiResult:
         return self._request(path, payload)
 

trodo/client.py

@@ -7,6 +7,7 @@ from typing import Any, Callable, Dict, List, Optional, Union
 
 from .api.http_client import HttpClient
 from .session.session_manager import SessionManager
+from .util.lru import LruDict
 from .managers.group_manager import GroupProfile
 from .queue.event_queue import EventQueue
 from .queue.batch_flusher import BatchFlusher
@@ -59,6 +60,7 @@ class TrodoClient:
         auto_instrument: bool = True,
         disable_instrumentations: Optional[List[str]] = None,
         otel_mode: str = "trodo",
+        max_cached_users: int = 10_000,
     ) -> None:
         if not site_id:
             raise ValueError("trodo-python: site_id is required")
@@ -75,10 +77,11 @@ class TrodoClient:
             debug=debug,
         )
 
-        self._session_manager = SessionManager()
+        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:
             self._event_queue: Optional[EventQueue] = EventQueue(batch_size)
@@ -97,7 +100,10 @@ class TrodoClient:
         if auto_events:
             self._auto_event_manager.enable()
 
-        self._user_context_cache: Dict[str, UserContext] = {}
+        # LRU-bounded (max_cached_users, default 10k). ``for_user`` caches a
+        # context per distinct id; unbounded that is a slow leak in a long-lived
+        # API server. An evicted user is simply rebuilt on next use.
+        self._user_context_cache: LruDict[str, UserContext] = LruDict(max_cached_users)
 
         self._span_processor = TrodoSpanProcessor(http_client=self._http)
         if auto_instrument:
@@ -137,12 +143,21 @@ class TrodoClient:
 
     @property
     def experiments(self):
-        """Ingest experiment result batches for server-side grading."""
+        """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
+        primitive. See :class:`~trodo.managers.user_manager.UserManager`."""
+        if self._users is None:
+            from .managers.user_manager import UserManager
+            self._users = UserManager(self._http)
+        return self._users
+
     # --------------------------------------------------------------------------
     # Primary pattern: for_user()
     # --------------------------------------------------------------------------
@@ -152,8 +167,9 @@ class TrodoClient:
         distinct_id: str,
         session_id: Optional[str] = None,
     ) -> UserContext:
-        if distinct_id in self._user_context_cache:
-            return self._user_context_cache[distinct_id]
+        cached = self._user_context_cache.get(distinct_id)
+        if cached is not None:
+            return cached
 
         ctx = UserContext(
             distinct_id=distinct_id,
@@ -165,7 +181,7 @@ class TrodoClient:
             auto_event_manager=self._auto_event_manager,
             session_id=session_id,
         )
-        self._user_context_cache[distinct_id] = ctx
+        self._user_context_cache.set(distinct_id, ctx)
         return ctx
 
     # --------------------------------------------------------------------------
@@ -182,8 +198,9 @@ class TrodoClient:
         self.for_user(distinct_id).track(event_name, properties, category)
 
     def identify(self, identify_id: str, session_id: Optional[str] = None) -> "UserContext":
-        if identify_id in self._user_context_cache:
-            return self._user_context_cache[identify_id]
+        cached = self._user_context_cache.get(identify_id)
+        if cached is not None:
+            return cached
         ctx = self.for_user(identify_id, session_id)
         ctx.identify(identify_id)
         return ctx
@@ -195,6 +212,26 @@ class TrodoClient:
         self._user_context_cache.pop(distinct_id, None)
         return self.for_user(distinct_id).reset()
 
+    def upsert_user(
+        self,
+        distinct_id: str,
+        *,
+        properties: Optional[Dict[str, Any]] = None,
+        set_once: Optional[Dict[str, Any]] = None,
+        fixed_properties: Optional[Dict[str, Any]] = None,
+    ) -> ApiResult:
+        """Create-or-update a user and their traits in one idempotent call.
+
+        Flat alias for ``client.users.upsert(...)``, matching the ``people_set``
+        convention.
+        """
+        return self.users.upsert(
+            distinct_id,
+            properties=properties,
+            set_once=set_once,
+            fixed_properties=fixed_properties,
+        )
+
     # People (direct)
     def people_set(self, distinct_id: str, properties: Dict[str, Any]) -> ApiResult:
         return self.for_user(distinct_id).people.set(properties)
@@ -289,11 +326,19 @@ class TrodoClient:
         conversation_id: Optional[str] = None,
         parent_run_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        user: Optional[Dict[str, Any]] = None,
     ) -> wrap_agent_ctx:
         """Context manager that captures the wrapped block as an agent run.
 
         Every OTel-instrumented call (Anthropic, OpenAI, LangChain…) made
         inside the ``with`` is auto-captured as a nested span.
+
+        ``user`` optionally carries profile traits — ``{"properties": ...,
+        "set_once": ..., "fixed_properties": ...}`` — so a stateless request
+        handler can attribute the run AND enrich the profile in one round trip
+        instead of a separate ``upsert_user`` call it has to sequence
+        correctly. Applied server-side and non-fatally: a failed trait write
+        never costs you the trace. Use ``upsert_user`` when you need the result.
         """
         return wrap_agent_ctx(
             processor=self._span_processor,
@@ -303,6 +348,7 @@ class TrodoClient:
             conversation_id=conversation_id,
             parent_run_id=parent_run_id,
             metadata=metadata,
+            user=user,
         )
 
     def agent(
@@ -352,10 +398,13 @@ class TrodoClient:
         parent_run_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
         input: Any = None,
+        user: Optional[Dict[str, Any]] = None,
     ) -> str:
         """Open a Run record outside a context manager. Returns the run_id.
 
         Use ``end_run`` to finalise, ``join_run`` from any process to add spans.
+
+        ``user`` carries profile traits alongside the run — see ``wrap_agent``.
         """
         return start_run_fn(
             processor=self._span_processor,
@@ -366,6 +415,7 @@ class TrodoClient:
             parent_run_id=parent_run_id,
             metadata=metadata,
             input=input,
+            user=user,
         )
 
     def end_run(

trodo/managers/experiment_manager.py

@@ -1,26 +1,25 @@
-"""Experiment ingest — record a batch of model outputs against a dataset.
+"""Experiment manager — managed runs and external ingest.
 
-An experiment takes a dataset (the fixed inputs) and a set of *outputs* your
-model produced for each item, then grades them server-side using the judge
-and/or evaluators you name. You run the model yourself and hand Trodo the
-results; Trodo scores and stores them so runs are comparable over time.
+Managed experiments (prompt + model over a dataset snapshot) use
+``create``, ``run``, ``get``, ``wait``, and ``compare``.
+External agent outputs use ``ingest``.
 
-``outputs`` are matched to dataset items by ``item_position`` (0-based),
-carrying the produced ``output`` and optional per-row context (``query``,
-``context``), cost/latency telemetry, and a per-row ``expected_output`` override.
-
-Mirrors ``sdks/trodo-node-sdk/src/managers/ExperimentManager.ts`` in shape.
+Mirrors ``sdks/trodo-node-sdk/src/managers/ExperimentManager.ts``.
 """
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+import time
+from typing import Any, Dict, List, Optional, Union
 
 __all__ = ["ExperimentManager"]
 
-# Optional per-output fields, in wire order. ``item_position`` + ``output`` are
-# always required.
+_TERMINAL = frozenset({"completed", "failed"})
+
+# Optional per-output fields for ingest
 _OUTPUT_OPTIONAL = (
+    "item_position",
+    "dataset_item_id",
     "expected_output",
     "query",
     "context",
@@ -32,22 +31,79 @@ _OUTPUT_OPTIONAL = (
 def _clean_output(output: Dict[str, Any]) -> Dict[str, Any]:
     if not isinstance(output, dict):
         raise ValueError("trodo: each experiment output must be a dict")
-    if output.get("item_position") is None:
-        raise ValueError("trodo: each output requires an 'item_position' (int)")
     if output.get("output") is None:
         raise ValueError("trodo: each output requires an 'output' (str)")
-    out: Dict[str, Any] = {
-        "item_position": output["item_position"],
-        "output": output["output"],
-    }
+    if output.get("item_position") is None and output.get("dataset_item_id") is None:
+        raise ValueError(
+            "trodo: each output requires 'item_position' and/or 'dataset_item_id'"
+        )
+    out: Dict[str, Any] = {"output": output["output"]}
     for key in _OUTPUT_OPTIONAL:
         if output.get(key) is not None:
             out[key] = output[key]
     return out
 
 
+def _unwrap_experiment(res: Any) -> Dict[str, Any]:
+    if isinstance(res, dict) and "experiment" in res:
+        return res["experiment"]
+    return res if isinstance(res, dict) else {}
+
+
+def _build_managed_body(
+    *,
+    dataset: Optional[str] = None,
+    dataset_id: Optional[str] = None,
+    dataset_version_no: Optional[int] = None,
+    name: Optional[str] = None,
+    prompt_ref: Optional[Dict[str, Any]] = None,
+    prompt_version_id: Optional[str] = None,
+    prompt_id: Optional[str] = None,
+    use_prompt: Optional[bool] = None,
+    models: Optional[List[Dict[str, Any]]] = None,
+    scorer_ids: Optional[List[Union[str, int]]] = None,
+    evaluator_ids: Optional[List[Union[str, int]]] = None,
+    deep_eval: Optional[bool] = None,
+    stability_runs: Optional[int] = None,
+    row_limit: Optional[int] = None,
+    concurrency: Optional[int] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    body: Dict[str, Any] = {"models": models or []}
+    ds = dataset_id or dataset
+    if ds:
+        body["dataset_id"] = ds
+    if dataset_version_no is not None:
+        body["dataset_version_no"] = dataset_version_no
+    if name is not None:
+        body["name"] = name
+    if prompt_ref is not None:
+        body["prompt_ref"] = prompt_ref
+    if prompt_version_id is not None:
+        body["prompt_version_id"] = prompt_version_id
+    if prompt_id is not None:
+        body["prompt_id"] = prompt_id
+    if use_prompt is False:
+        body["use_prompt"] = False
+    ids = scorer_ids if scorer_ids is not None else evaluator_ids
+    if ids is not None:
+        body["scorer_ids"] = ids
+        body["evaluator_ids"] = ids
+    if deep_eval is not None:
+        body["deep_eval"] = deep_eval
+    if stability_runs is not None:
+        body["stability_runs"] = stability_runs
+    if row_limit is not None:
+        body["row_limit"] = row_limit
+    if concurrency is not None:
+        body["concurrency"] = concurrency
+    if metadata is not None:
+        body["metadata"] = metadata
+    return body
+
+
 class ExperimentManager:
-    """Ingest experiment result batches for server-side grading."""
+    """Run and inspect Trodo experiments programmatically."""
 
     def __init__(self, http_client: Any) -> None:
         self._http = http_client
@@ -62,23 +118,7 @@ class ExperimentManager:
         evaluator_ids: Optional[List[str]] = None,
         dataset_version_no: Optional[int] = None,
     ) -> Dict[str, Any]:
-        """Ingest a batch of *outputs* for *dataset* and return the experiment.
-
-        *dataset* is a dataset name or UUID. *outputs* is a list of dicts shaped
-        ``{"item_position": int, "output": str, "expected_output"?, "query"?,
-        "context"?, "cost_usd"?, "latency_ms"?}``. ``None`` optional fields are
-        dropped from the wire payload.
-
-        Grading is configured server-side: pass ``judge`` (``{"credential_id",
-        "provider", "model"}``) for an LLM judge and/or ``evaluator_ids`` for
-        named evaluators. ``dataset_version_no`` pins the dataset version graded
-        against.
-
-        Returns the experiment dict from ``{"experiment": {...}}``.
-
-        :raises ValueError: if *dataset* is empty, *outputs* is empty, or an
-            output is missing ``item_position``/``output``.
-        """
+        """Ingest externally-produced outputs and grade them (external task path)."""
         if not dataset:
             raise ValueError("trodo: ingest_experiment(dataset) requires a dataset")
         if not outputs:
@@ -99,7 +139,148 @@ class ExperimentManager:
         if dataset_version_no is not None:
             body["dataset_version_no"] = dataset_version_no
 
-        res = self._http.ingest_experiment(body)
-        if isinstance(res, dict) and "experiment" in res:
-            return res["experiment"]
-        return res
+        return _unwrap_experiment(self._http.ingest_experiment(body))
+
+    def create(
+        self,
+        *,
+        dataset: Optional[str] = None,
+        dataset_id: Optional[str] = None,
+        models: List[Dict[str, Any]],
+        dataset_version_no: Optional[int] = None,
+        name: Optional[str] = None,
+        prompt_ref: Optional[Dict[str, Any]] = None,
+        prompt_version_id: Optional[str] = None,
+        prompt_id: Optional[str] = None,
+        use_prompt: Optional[bool] = None,
+        scorer_ids: Optional[List[Union[str, int]]] = None,
+        evaluator_ids: Optional[List[Union[str, int]]] = None,
+        deep_eval: Optional[bool] = None,
+        stability_runs: Optional[int] = None,
+        row_limit: Optional[int] = None,
+        concurrency: Optional[int] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Create an experiment (immutable refs, status pending)."""
+        self._validate_run_params(dataset, dataset_id, models)
+        body = _build_managed_body(
+            dataset=dataset,
+            dataset_id=dataset_id,
+            dataset_version_no=dataset_version_no,
+            name=name,
+            prompt_ref=prompt_ref,
+            prompt_version_id=prompt_version_id,
+            prompt_id=prompt_id,
+            use_prompt=use_prompt,
+            models=models,
+            scorer_ids=scorer_ids,
+            evaluator_ids=evaluator_ids,
+            deep_eval=deep_eval,
+            stability_runs=stability_runs,
+            row_limit=row_limit,
+            concurrency=concurrency,
+            metadata=metadata,
+        )
+        return _unwrap_experiment(self._http.create_experiment(body))
+
+    def run(
+        self,
+        *,
+        dataset: Optional[str] = None,
+        dataset_id: Optional[str] = None,
+        models: List[Dict[str, Any]],
+        dataset_version_no: Optional[int] = None,
+        name: Optional[str] = None,
+        prompt_ref: Optional[Dict[str, Any]] = None,
+        prompt_version_id: Optional[str] = None,
+        prompt_id: Optional[str] = None,
+        use_prompt: Optional[bool] = None,
+        scorer_ids: Optional[List[Union[str, int]]] = None,
+        evaluator_ids: Optional[List[Union[str, int]]] = None,
+        deep_eval: Optional[bool] = None,
+        stability_runs: Optional[int] = None,
+        row_limit: Optional[int] = None,
+        concurrency: Optional[int] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Create and execute an experiment synchronously."""
+        self._validate_run_params(dataset, dataset_id, models)
+        body = _build_managed_body(
+            dataset=dataset,
+            dataset_id=dataset_id,
+            dataset_version_no=dataset_version_no,
+            name=name,
+            prompt_ref=prompt_ref,
+            prompt_version_id=prompt_version_id,
+            prompt_id=prompt_id,
+            use_prompt=use_prompt,
+            models=models,
+            scorer_ids=scorer_ids,
+            evaluator_ids=evaluator_ids,
+            deep_eval=deep_eval,
+            stability_runs=stability_runs,
+            row_limit=row_limit,
+            concurrency=concurrency,
+            metadata=metadata,
+        )
+        return _unwrap_experiment(self._http.run_experiment(body))
+
+    def run_by_id(self, experiment_id: str) -> Dict[str, Any]:
+        """Execute a pending experiment created via ``create``."""
+        if not experiment_id:
+            raise ValueError("trodo: run_by_id requires an experiment id")
+        return _unwrap_experiment(self._http.run_experiment_by_id(experiment_id))
+
+    def get(self, experiment_id: str) -> Dict[str, Any]:
+        """Fetch an experiment by id."""
+        if not experiment_id:
+            raise ValueError("trodo: get requires an experiment id")
+        res = self._http.get_experiment(experiment_id)
+        if isinstance(res, dict) and res.get("__error"):
+            raise RuntimeError(f"trodo: get failed (HTTP {res.get('status')})")
+        return _unwrap_experiment(res)
+
+    def wait(
+        self,
+        experiment_id: str,
+        *,
+        interval_ms: int = 2500,
+        timeout_ms: int = 600_000,
+    ) -> Dict[str, Any]:
+        """Poll until the experiment reaches a terminal status."""
+        deadline = time.monotonic() + (timeout_ms / 1000.0)
+        while True:
+            exp = self.get(experiment_id)
+            status = str(exp.get("status") or "").lower()
+            if status in _TERMINAL:
+                return exp
+            if time.monotonic() >= deadline:
+                raise TimeoutError(
+                    f"trodo: wait timed out after {timeout_ms}ms (status: {status or 'unknown'})"
+                )
+            time.sleep(interval_ms / 1000.0)
+
+    def compare(
+        self, a_id: str, b_id: str, *, strict: bool = False
+    ) -> Dict[str, Any]:
+        """Compare two experiments side by side."""
+        if not a_id or not b_id:
+            raise ValueError("trodo: compare requires two experiment ids")
+        res = self._http.compare_experiments(a_id, b_id, strict=strict)
+        if isinstance(res, dict) and res.get("__error"):
+            raise RuntimeError(f"trodo: compare failed (HTTP {res.get('status')})")
+        return res if isinstance(res, dict) else {}
+
+    @staticmethod
+    def _validate_run_params(
+        dataset: Optional[str],
+        dataset_id: Optional[str],
+        models: Optional[List[Dict[str, Any]]],
+    ) -> None:
+        if not models:
+            raise ValueError("trodo: run requires a non-empty models list")
+        if not dataset and not dataset_id:
+            raise ValueError("trodo: run requires dataset or dataset_id")
+        for model in models:
+            if not model.get("credential_id") or not model.get("model"):
+                raise ValueError("trodo: each model needs credential_id and model")

trodo/managers/user_manager.py

@@ -0,0 +1,70 @@
+"""User upsert — create-or-update a user and their traits in one call.
+
+Backend services are stateless: a request handler knows who the user is and a
+few things about them for the duration of one request, and holds nothing between
+requests. This is the call that expresses that.
+
+    trodo.upsert_user(
+        "user-42",
+        properties={"plan": "pro"},
+        set_once={"signup_date": "2026-01-04"},
+        fixed_properties={"last_location_country": "India"},
+    )
+
+Every bag is optional. With none of them it still ensures the user exists —
+useful at signup, before they have produced any agent runs. Safe to call on
+every request: it is idempotent, and ``set_once`` keys are only written the
+first time.
+
+Mirrors ``sdks/trodo-node-sdk/src/managers/UserManager.ts``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from ..types import ApiResult
+
+__all__ = ["UserManager"]
+
+
+class UserManager:
+    def __init__(self, http_client: object) -> None:
+        self._http = http_client
+
+    def upsert(
+        self,
+        distinct_id: str,
+        *,
+        properties: Optional[Dict[str, Any]] = None,
+        set_once: Optional[Dict[str, Any]] = None,
+        fixed_properties: Optional[Dict[str, Any]] = None,
+    ) -> ApiResult:
+        """Create or update ``distinct_id`` and apply the supplied traits.
+
+        :param distinct_id: The user's id — the same value passed as
+            ``distinct_id`` to ``wrap_agent``, and the same one the browser SDK
+            calls ``identify()`` with. Matching them is what merges a user's
+            agent runs and product events into one profile.
+        :param properties: Merged into the user's custom properties.
+        :param set_once: Written only where the key is absent.
+        :param fixed_properties: Allowlisted real columns —
+            ``first/last_location_country`` and ``first/last_location_city``.
+            Device, browser, OS, referrer and UTM are browser observations and
+            come back in ``skipped`` rather than being stored; a backend
+            supplying them is guessing.
+
+        :returns: ``{"success", "distinctId", "created", "applied", "skipped"}``.
+            A skipped fixed key is a normal outcome (browser-owned or
+            browser-only), not an error.
+        """
+        # Absent bags are omitted rather than sent as null: the server
+        # distinguishes "no bag" from "empty bag" by presence.
+        payload: Dict[str, Any] = {"distinctId": distinct_id}
+        if properties is not None:
+            payload["properties"] = properties
+        if set_once is not None:
+            payload["setOnce"] = set_once
+        if fixed_properties is not None:
+            payload["fixedProperties"] = fixed_properties
+        return self._http.post_user_upsert(payload)  # type: ignore[attr-defined]

trodo/otel/processor.py

@@ -36,6 +36,10 @@ class TrodoRun:
     # Free-form run-level attributes (e.g. {"trodo.prompts": [...]} — the set of
     # managed-prompt versions used across the run, for prompt traceability).
     attributes: Optional[Dict[str, Any]] = None
+    # Optional user traits applied alongside the run (see wrap_agent's `user`
+    # kwarg). Forwarded verbatim to the backend, which applies them
+    # non-fatally — this is not a run column.
+    user: Optional[Dict[str, Any]] = None
     # Aggregates summed from child spans at finalisation.
     total_tokens_in: Optional[int] = None
     total_tokens_out: Optional[int] = None

trodo/otel/wrap_agent.py

@@ -212,6 +212,30 @@ def _aggregate(spans: list[TrodoSpan]) -> Dict[str, Any]:
     }
 
 
+def _user_bag(user: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
+    """Normalise a user-traits bag for the wire, or None when it carries
+    nothing.
+
+    Accepts both snake_case (``set_once`` / ``fixed_properties``, natural in
+    Python) and the camelCase the wire uses, so callers can write either.
+    Omitting an empty bag keeps the payload honest — the backend distinguishes
+    "no traits" from "empty traits" by presence.
+    """
+    if not isinstance(user, dict):
+        return None
+    out: Dict[str, Any] = {}
+    props = user.get("properties")
+    once = user.get("set_once", user.get("setOnce"))
+    fixed = user.get("fixed_properties", user.get("fixedProperties"))
+    if isinstance(props, dict) and props:
+        out["properties"] = props
+    if isinstance(once, dict) and once:
+        out["setOnce"] = once
+    if isinstance(fixed, dict) and fixed:
+        out["fixedProperties"] = fixed
+    return out or None
+
+
 def _mint_anon_distinct_id() -> str:
     """Mint a server-side anonymous distinct_id for an agent run.
 
@@ -420,6 +444,7 @@ def start_run(
     parent_run_id: Optional[str] = None,
     metadata: Optional[Dict[str, Any]] = None,
     input: Any = None,
+    user: Optional[Dict[str, Any]] = None,
 ) -> str:
     """Open a Run record without holding a context manager.
 
@@ -448,6 +473,7 @@ def start_run(
         input=_prepare_value(input),
         started_at=_now_iso(),
         metadata=metadata,
+        user=_user_bag(user),
     )
     processor.mark_joined(rid)
     processor.start_run(run)
@@ -503,6 +529,7 @@ class wrap_agent:
         conversation_id: Optional[str] = None,
         parent_run_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        user: Optional[Dict[str, Any]] = None,
     ) -> None:
         self._processor = processor
         self._team_site_id = team_site_id
@@ -515,6 +542,7 @@ class wrap_agent:
         self._conversation_id = conversation_id
         self._parent_run_id = parent_run_id
         self._metadata = metadata
+        self._user = _user_bag(user)
         self._ctx_mgr: Optional[run_with_context] = None
         self._ctx: Optional[ActiveSpanContext] = None
         self._started_ms: float = 0.0
@@ -600,6 +628,9 @@ class wrap_agent:
             error_summary=error_summary,
             error_type=error_type,
             metadata={**(self._metadata or {}), **self.handle.metadata} or None,
+            # Traits travel on the failure path too — a run that threw is
+            # exactly when you still want to know who the user was.
+            user=self._user,
             attributes=(
                 {"trodo.prompts": self._ctx.prompt_state["all"]}
                 if self._ctx is not None

trodo/session/session_manager.py

@@ -6,12 +6,17 @@ import threading
 from typing import Dict, Optional
 
 from ..types import ServerSession
+from ..util.lru import DEFAULT_MAX_SIZE, LruDict
 from .server_session import build_session_payload, create_server_session
 
 
 class SessionManager:
-    def __init__(self) -> None:
-        self._sessions: Dict[str, ServerSession] = {}
+    def __init__(self, max_cached_users: int = DEFAULT_MAX_SIZE) -> None:
+        # LRU-bounded: one entry per distinct id, and a long-lived backend can
+        # see unbounded distinct ids. Evicted users are rebuilt on next use, and
+        # the server session id is deterministic (``server:{distinct_id}``), so a
+        # rebuild resolves to the same session rather than creating a duplicate.
+        self._sessions: LruDict[str, ServerSession] = LruDict(max_cached_users)
         self._lock = threading.Lock()
         self._confirmation_locks: Dict[str, threading.Event] = {}
         self._confirmation_started: Dict[str, bool] = {}
@@ -23,10 +28,11 @@ class SessionManager:
         session_id: Optional[str] = None,
     ) -> ServerSession:
         with self._lock:
-            if distinct_id in self._sessions:
-                return self._sessions[distinct_id]
+            existing = self._sessions.get(distinct_id)
+            if existing is not None:
+                return existing
             session = create_server_session(site_id, distinct_id, session_id)
-            self._sessions[distinct_id] = session
+            self._sessions.set(distinct_id, session)
             return session
 
     def ensure_confirmed(self, session: ServerSession, http_client: object) -> None:

trodo/user_context.py

@@ -45,13 +45,16 @@ class UserContext:
         self._batch_flusher = batch_flusher
         self._auto_event_manager = auto_event_manager
         self._session_id_override = session_id
+        # Created on first use, not here.
+        #
+        # The session used to be built eagerly, which meant
+        # ``for_user(id).people.set(...)`` constructed a session object it never
+        # sent or read — pure waste on the stateless-backend path, where setting
+        # a property on a user you will not otherwise touch is a common call.
+        # Sessions are now created by the first operation that needs one
+        # (track / identify / wallet_address / capture_error).
         self._session: Optional["ServerSession"] = None
 
-        # Eagerly initialise session
-        self._session = self._session_manager.get_or_create(
-            distinct_id, site_id, session_id
-        )
-
         self.people = PeopleManager(
             http_client, site_id, lambda: self._get_distinct_id()
         )

trodo/util/__init__.py

@@ -0,0 +1 @@
+"""Internal utilities. Not part of the public API."""

trodo/util/lru.py

@@ -0,0 +1,71 @@
+"""A dict with a size ceiling that evicts least-recently-used entries.
+
+The SDK caches one context and one session per distinct id so repeated calls for
+the same user reuse them. Unbounded, that is a slow leak in exactly the
+deployment this SDK targets: a long-lived API server whose user cardinality
+grows without limit. A worker touching ten users never noticed; a service
+touching a million did.
+
+Eviction is safe because every cached value is reconstructible — an evicted user
+is rebuilt on next use, and server session ids are deterministic
+(``server:{distinct_id}``), so rebuilding produces the same session rather than a
+duplicate. The only cost of a miss is re-creating a small object.
+
+Backed by :class:`collections.OrderedDict`, whose ``move_to_end`` gives the
+recency ordering directly. Guarded by a lock because backend SDK users routinely
+call from a thread pool.
+
+Mirrors ``sdks/trodo-node-sdk/src/util/LruMap.ts``.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections import OrderedDict
+from typing import Any, Generic, Optional, TypeVar
+
+__all__ = ["LruDict"]
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+DEFAULT_MAX_SIZE = 10_000
+
+
+class LruDict(Generic[K, V]):
+    def __init__(self, max_size: int = DEFAULT_MAX_SIZE) -> None:
+        # A non-positive cap would evict on every set and defeat the cache;
+        # treat it as "no caching is not a supported mode".
+        self._max_size = max_size if isinstance(max_size, int) and max_size > 0 else DEFAULT_MAX_SIZE
+        self._data: "OrderedDict[K, V]" = OrderedDict()
+        self._lock = threading.Lock()
+
+    def get(self, key: K) -> Optional[V]:
+        with self._lock:
+            if key not in self._data:
+                return None
+            self._data.move_to_end(key)
+            return self._data[key]
+
+    def set(self, key: K, value: V) -> None:
+        with self._lock:
+            self._data[key] = value
+            self._data.move_to_end(key)
+            while len(self._data) > self._max_size:
+                self._data.popitem(last=False)
+
+    def pop(self, key: K, default: Any = None) -> Any:
+        with self._lock:
+            return self._data.pop(key, default)
+
+    def clear(self) -> None:
+        with self._lock:
+            self._data.clear()
+
+    def __contains__(self, key: object) -> bool:
+        with self._lock:
+            return key in self._data
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._data)

{trodo_python-2.16.0.dist-info → trodo_python-2.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 2.16.0
+Version: 2.18.0
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side
@@ -123,7 +123,7 @@ Creates the session and fires `POST /api/sdk/identify`. Use to link a `distinct_
 
 ```python
 user = trodo.identify('user@example.com', session_id=request.cookies.get('trodo_session'))
-# distinct_id is now id_user@example.com — merges with browser events
+# distinct_id is now user@example.com — merges with browser events
 user.track('login')
 ```
 
@@ -171,6 +171,59 @@ trodo.people_set('user-123', {'plan': 'pro'})
 trodo.set_group('user-123', 'company', 'acme')
 ```
 
+### `upsert_user` — identity and traits in one call
+
+Create-or-update a user and their traits idempotently. This is the call a
+stateless request handler makes; safe to run on every request.
+
+```python
+result = trodo.upsert_user(
+    'user-42',
+    properties={'plan': 'pro', 'company': 'Acme'},        # merged
+    set_once={'signup_date': '2026-01-04'},               # fill-if-absent
+    fixed_properties={'last_location_country': 'India'},
+)
+
+result['created']                  # True if this call created the user
+result['applied']['properties']    # ['plan', 'company']
+result['skipped']['fixedProperties']
+```
+
+All three bags are optional. With none of them it still ensures the user
+exists — what you want at signup, before they've produced any runs.
+
+**Fixed vs custom properties.** `properties` / `set_once` are free-form and live
+on the profile as custom properties. `fixed_properties` writes the real columns
+the dashboard filters on, and only a backend-knowable subset is accepted:
+
+| Settable from a backend | Browser-only |
+|---|---|
+| `first_location_country`, `last_location_country` | `device_type`, `browser_name`, `os` |
+| `first_location_city`, `last_location_city` | `first_referrer`, `last_referrer`, `utm_*` |
+
+A browser-only key isn't an error — it comes back in `skipped` with
+`reason: 'BROWSER_ONLY_PROPERTY'` and the rest of the batch still applies. The
+reasoning: a backend supplying a browser name is guessing, and a wrong guess
+silently corrupts attribution reporting.
+
+Where both a browser and a backend write the same column, **the browser wins** —
+it observed the value, the server supplied one — and the server write is
+reported as `BROWSER_OWNED_PROPERTY`.
+
+### Attributing and enriching in one call
+
+`wrap_agent` and `start_run` take an optional `user=` bag, so a request handler
+doesn't need a separate `upsert_user` call it has to sequence correctly:
+
+```python
+with trodo.wrap_agent('support-agent', distinct_id=user_id,
+                      user={'properties': {'plan': 'pro'}}) as run:
+    ...
+```
+
+Applied server-side and non-fatally — a failed trait write never costs you the
+trace. Use `upsert_user` directly when you need to know what landed.
+
 ---
 
 ## AI Agent Tracing (recommended)
@@ -617,10 +670,10 @@ Call `identify()` with the **same value** on the browser and server to merge all
 
 ```python
 # Python
-user.identify('user@example.com')   # → id_user@example.com
+user.identify('user@example.com')   # → user@example.com
 
 # Browser (same value)
-# Trodo.identify('user@example.com') → id_user@example.com
+# Trodo.identify('user@example.com') → user@example.com
 # Events from both sides now appear together in the dashboard
 ```
 

{trodo_python-2.16.0.dist-info → trodo_python-2.18.0.dist-info}/RECORD

@@ -1,28 +1,29 @@
-trodo/__init__.py,sha256=V2vh8SxMkgOaBdowPlHzx_2hpX4T1lUlS2JmE6usz3M,23362
-trodo/client.py,sha256=syz4zzWokdBaFNnO5QhYnUKVNHf8KaunofVFc1ODohI,20187
+trodo/__init__.py,sha256=Z24IqU5MsOX2VP6xwWcgpy5UiJb3DniXFmQPiiYlxtQ,26243
+trodo/client.py,sha256=5Uxt0tTLDjuMlXIqqdTbg4uiuISY5u7MTK4F1wahdfc,22281
 trodo/types.py,sha256=eySgUvCXROG2TxtxgiU0MNr5iH0DEcduK8bmYtTKG44,3138
-trodo/user_context.py,sha256=9la6azzwEanVmdP4ps_xMoufbeWVeIGU-M8ychmgajg,7859
+trodo/user_context.py,sha256=uHCI2WYoOI3cNwdIUEuZdX4VYSu14pzm348ksn6hn_c,8195
 trodo/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trodo/api/async_client.py,sha256=rZN4aJ2QiKyrHBK260bApCUB9JaMWU6BQtzoSJZh7xk,3408
-trodo/api/endpoints.py,sha256=JVTn5l1U-7U2ibQoR9M_AjRgK6GMRgSx_DkV4opWouo,1171
-trodo/api/http_client.py,sha256=rWeRLqVXQ-iXgAIzg6701WtK5eSlPZTTJgKZFerLZhs,8085
+trodo/api/endpoints.py,sha256=H0Da456mf2IUNZH5bsln69IIUoUhdF4bncPo-WDLZ9I,1433
+trodo/api/http_client.py,sha256=RRsXVDqTp3H8OrOqM-7tsE3_WKHYCuRkf9icvyowVQE,9577
 trodo/auto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trodo/auto/auto_event_manager.py,sha256=cztuRsRkNoJE5R4NfSfTrTJTGl4jx2Yb-Ncy0aVAPo8,4247
 trodo/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trodo/managers/dataset_manager.py,sha256=gx0S8ujG3cbw4IskBNMdceBjDbcEh_nebwKSzEvm7hE,2827
-trodo/managers/experiment_manager.py,sha256=9GO1JUuV7FykaPfZXI8NVvEBDS2CZuyw9I3ywCrZBTI,3916
+trodo/managers/experiment_manager.py,sha256=V-vemLtenfSI5VIcP0HPiXzEy8AyTrRrbJVCA9Z6wjo,10579
 trodo/managers/group_manager.py,sha256=ki3Se3qEoSZfREX63oeDeBmEfZF-ISHLE8azEtLg0tM,3542
 trodo/managers/people_manager.py,sha256=mMVnx40Mlifx6NGgChvohC9ViK6dQu2mkXNHbV8pK1E,2882
 trodo/managers/prompt_manager.py,sha256=jFHkdvDSxvvb9c53EQvBQygdDJ7X-ylNWEY_ag_SeC0,11227
+trodo/managers/user_manager.py,sha256=faJYX3CHrD7ulYiShV7FhThSMX9aJ3kdOgU4Qtdy5FM,2844
 trodo/otel/__init__.py,sha256=yiRFXWUU45bAM2CV37XeO7zf1hmnmjufdP4XO50yEyE,624
 trodo/otel/auto_instrument.py,sha256=Iae9A9lvh2PImE6gqnyEMXeRPRpjTxZcxx1zW2KDLac,21467
 trodo/otel/context.py,sha256=Jd0aTc0Q-1dM5kXXinhZD8YtnpdKgvneNiODyboVGKY,1418
 trodo/otel/helpers.py,sha256=XOMWcgZHaq5SQbkFxDaXPE4CDFjn01xjJmJ1vIxvwpw,20730
-trodo/otel/processor.py,sha256=ffhrzPDUBwEzeUBa9k5oKnl6vw7NV0urAoco2Z2aiVY,7703
+trodo/otel/processor.py,sha256=LKlXxP3BeQ7DP8SzYAgXZZOeJ6-6b7e43i19gCUC_0Y,7939
 trodo/otel/prompt_trace.py,sha256=BIrdLOpsR1_HoaCmWb_706GwZSs-UG3p76fjvX3CX3w,3391
 trodo/otel/register.py,sha256=bV_ePTfUvPugig2GZnylhzxi2QfoPWs96A9mGLPMrSQ,9387
 trodo/otel/transport.py,sha256=hzZz8gwSMGJ8CxdijmLn1Ljt18owr9XTWy13DLbwYbw,2441
-trodo/otel/wrap_agent.py,sha256=9lsrt6o25dZ8RGdHXERRF-PbZ8RqIoX1dw_cXF_dBdQ,39724
+trodo/otel/wrap_agent.py,sha256=cJjrzlZNW2g6q_coLN7UR4uxn65h4u3-LNzMfE4dLVw,40999
 trodo/prompts/__init__.py,sha256=yunNc8WkTSfEEkRR-NZWXAt_ZB3Ee2INRh-4RE7uHj4,806
 trodo/prompts/compile.py,sha256=sEMl8EWdK0G9uOKGcgc39ujnA5RLCUtbk26TYVqK68Q,6345
 trodo/prompts/template.py,sha256=obQiivPCR6LEdz7q1cby7uL25tYHYui4aoEaiUNqWfs,9357
@@ -32,8 +33,10 @@ trodo/queue/batch_flusher.py,sha256=4Lg6T3Urwi9U0Q4FpFGPmjDYKg4ZliCTR-ND8BJvWaY,
 trodo/queue/event_queue.py,sha256=EVFZrhlq_kwC3jJ2GK0wMhHISf9UzLCZNDnT_aZ2I2A,872
 trodo/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trodo/session/server_session.py,sha256=McsudEiq33XDq3nqxgzBcUvIjQxCMscwEuAPnYXrTjs,2136
-trodo/session/session_manager.py,sha256=JrgH1VeicmtlxPR4dXEuJbxhi23OelkgwW3-9Slv80o,2525
-trodo_python-2.16.0.dist-info/METADATA,sha256=i4J0WgohVDAcQi8OCVa_x6WpDhH9mWeYCEgX8BQ2lLs,23115
-trodo_python-2.16.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-trodo_python-2.16.0.dist-info/top_level.txt,sha256=VCQu1CJWFmNsqTs1YxMcw4Mq35Tc3z3uI9RwHEXAayQ,6
-trodo_python-2.16.0.dist-info/RECORD,,
+trodo/session/session_manager.py,sha256=7ht5LeeZX1HLLfPeNV_a8NkXGbHl3up0CRtCGr3EzjQ,2995
+trodo/util/__init__.py,sha256=Z9c4rPPdKg06Kk3byKheDqksSgR4WNvS475oQ5sNljc,54
+trodo/util/lru.py,sha256=QIsM7s6J_E9ZjiXatSyReZIEeGypTAcgrPWWy8YsRa4,2465
+trodo_python-2.18.0.dist-info/METADATA,sha256=Pa8V9NdIZEs6q0o4dyj4WIOBKBmd52xEt-NRQ_LgfUo,25308
+trodo_python-2.18.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+trodo_python-2.18.0.dist-info/top_level.txt,sha256=VCQu1CJWFmNsqTs1YxMcw4Mq35Tc3z3uI9RwHEXAayQ,6
+trodo_python-2.18.0.dist-info/RECORD,,

{trodo_python-2.16.0.dist-info → trodo_python-2.18.0.dist-info}/WHEEL

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