trodo-python 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

trodo/api/http_client.py

@@ -1,87 +1,90 @@
-"""Synchronous HTTP client using requests."""
-
-from __future__ import annotations
-
-import sys
-import time
-from typing import Any, Callable, Dict, Optional
-
-import requests
-
-from ..types import ApiResult, EventPayload
-
-
-class HttpClient:
-    def __init__(
-        self,
-        api_base: str,
-        site_id: str,
-        timeout: int = 10,
-        retries: int = 2,
-        on_error: Optional[Callable[[Exception], None]] = None,
-        debug: bool = False,
-    ) -> None:
-        self.api_base = api_base.rstrip("/")
-        self.site_id = site_id
-        self.timeout = timeout
-        self.retries = retries
-        self.on_error = on_error
-        self.debug = debug
-        self._session = requests.Session()
-        self._session.headers.update({
-            "Content-Type": "application/json",
-            "X-Trodo-Site-Id": self.site_id,
-        })
-
-    def _log(self, *args: Any) -> None:
-        if self.debug:
-            sys.stderr.write(f"[trodo-python] {' '.join(str(a) for a in args)}\n")
-
-    def _request(self, path: str, body: Dict[str, Any], attempt: int = 0) -> ApiResult:
-        url = f"{self.api_base}{path}"
-        self._log(f"POST {url}")
-        try:
-            resp = self._session.post(url, json=body, timeout=self.timeout)
-            if resp.status_code >= 500 and attempt < self.retries:
-                delay = 2 ** attempt
-                self._log(f"Retry {attempt + 1} after {delay}s (status {resp.status_code})")
-                time.sleep(delay)
-                return self._request(path, body, attempt + 1)
-            try:
-                return resp.json()
-            except Exception:
-                return {}
-        except Exception as exc:
-            if attempt < self.retries:
-                delay = 2 ** attempt
-                self._log(f"Retry {attempt + 1} after {delay}s (network error)")
-                time.sleep(delay)
-                return self._request(path, body, attempt + 1)
-            self._log(f"Error: {exc}")
-            if self.on_error:
-                self.on_error(exc)
-            return {}
-
-    def post_track(self, session_data: Dict[str, Any]) -> ApiResult:
-        return self._request("/api/sdk/track", {"sessionData": session_data})
-
-    def post_event(self, event: EventPayload) -> ApiResult:
-        return self._request("/api/events", event.to_dict())
-
-    def post_bulk_events(self, events: list) -> ApiResult:
-        return self._request("/api/events/bulk", {"events": [e.to_dict() for e in events]})
-
-    def post_identify(self, payload: Dict[str, Any]) -> ApiResult:
-        return self._request("/api/sdk/identify", payload)
-
-    def post_wallet_address(self, payload: Dict[str, Any]) -> ApiResult:
-        return self._request("/api/sdk/wallet-address", payload)
-
-    def post_reset(self, payload: Dict[str, Any]) -> ApiResult:
-        return self._request("/api/sdk/reset", payload)
-
-    def post_people(self, path: str, payload: Dict[str, Any]) -> ApiResult:
-        return self._request(path, payload)
-
-    def post_group(self, path: str, payload: Dict[str, Any]) -> ApiResult:
-        return self._request(path, payload)
+"""Synchronous HTTP client using requests."""
+
+from __future__ import annotations
+
+import sys
+import time
+from typing import Any, Callable, Dict, Optional
+
+import requests
+
+from ..types import ApiResult, EventPayload
+
+
+class HttpClient:
+    def __init__(
+        self,
+        api_base: str,
+        site_id: str,
+        timeout: int = 10,
+        retries: int = 2,
+        on_error: Optional[Callable[[Exception], None]] = None,
+        debug: bool = False,
+    ) -> None:
+        self.api_base = api_base.rstrip("/")
+        self.site_id = site_id
+        self.timeout = timeout
+        self.retries = retries
+        self.on_error = on_error
+        self.debug = debug
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Content-Type": "application/json",
+            "X-Trodo-Site-Id": self.site_id,
+        })
+
+    def _log(self, *args: Any) -> None:
+        if self.debug:
+            sys.stderr.write(f"[trodo-python] {' '.join(str(a) for a in args)}\n")
+
+    def _request(self, path: str, body: Dict[str, Any], attempt: int = 0) -> ApiResult:
+        url = f"{self.api_base}{path}"
+        self._log(f"POST {url}")
+        try:
+            resp = self._session.post(url, json=body, timeout=self.timeout)
+            if resp.status_code >= 500 and attempt < self.retries:
+                delay = 2 ** attempt
+                self._log(f"Retry {attempt + 1} after {delay}s (status {resp.status_code})")
+                time.sleep(delay)
+                return self._request(path, body, attempt + 1)
+            try:
+                return resp.json()
+            except Exception:
+                return {}
+        except Exception as exc:
+            if attempt < self.retries:
+                delay = 2 ** attempt
+                self._log(f"Retry {attempt + 1} after {delay}s (network error)")
+                time.sleep(delay)
+                return self._request(path, body, attempt + 1)
+            self._log(f"Error: {exc}")
+            if self.on_error:
+                self.on_error(exc)
+            return {}
+
+    def post_track(self, session_data: Dict[str, Any]) -> ApiResult:
+        return self._request("/api/sdk/track", {"sessionData": session_data})
+
+    def post_event(self, event: EventPayload) -> ApiResult:
+        return self._request("/api/events", event.to_dict())
+
+    def post_bulk_events(self, events: list) -> ApiResult:
+        return self._request("/api/events/bulk", {"events": [e.to_dict() for e in events]})
+
+    def post_identify(self, payload: Dict[str, Any]) -> ApiResult:
+        return self._request("/api/sdk/identify", payload)
+
+    def post_wallet_address(self, payload: Dict[str, Any]) -> ApiResult:
+        return self._request("/api/sdk/wallet-address", payload)
+
+    def post_reset(self, payload: Dict[str, Any]) -> ApiResult:
+        return self._request("/api/sdk/reset", payload)
+
+    def post_people(self, path: str, payload: Dict[str, Any]) -> ApiResult:
+        return self._request(path, payload)
+
+    def post_group(self, path: str, payload: Dict[str, Any]) -> ApiResult:
+        return self._request(path, payload)
+
+    def post_agent_event(self, payload: Dict[str, Any]) -> ApiResult:
+        return self._request("/api/sdk/track-agent", payload)

trodo/auto/auto_event_manager.py

@@ -1,134 +1,134 @@
-"""Auto event manager — captures unhandled Python exceptions as server_error events."""
-
-from __future__ import annotations
-
-import sys
-import threading
-import traceback
-from datetime import datetime, timezone
-from typing import Any, Optional, TYPE_CHECKING
-
-from ..types import EventPayload
-
-if TYPE_CHECKING:
-    from ..session.session_manager import SessionManager
-    from ..api.http_client import HttpClient
-
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-class AutoEventManager:
-    def __init__(
-        self,
-        site_id: str,
-        http_client: "HttpClient",
-        session_manager: "SessionManager",
-    ) -> None:
-        self._site_id = site_id
-        self._http = http_client
-        self._session_manager = session_manager
-        self._enabled = False
-        self._prev_excepthook: Any = None
-        self._prev_thread_excepthook: Any = None
-
-    def enable(self) -> None:
-        if self._enabled:
-            return
-        self._enabled = True
-
-        # Wrap sys.excepthook
-        self._prev_excepthook = sys.excepthook
-
-        def _excepthook(exc_type, exc_value, exc_tb):
-            self._track_error(
-                exc_type.__name__ if exc_type else "Exception",
-                str(exc_value),
-                "".join(traceback.format_exception(exc_type, exc_value, exc_tb)),
-            )
-            if self._prev_excepthook:
-                self._prev_excepthook(exc_type, exc_value, exc_tb)
-
-        sys.excepthook = _excepthook
-
-        # Wrap threading.excepthook (Python 3.8+)
-        if hasattr(threading, "excepthook"):
-            self._prev_thread_excepthook = threading.excepthook
-
-            def _thread_excepthook(args):
-                self._track_error(
-                    args.exc_type.__name__ if args.exc_type else "ThreadException",
-                    str(args.exc_value),
-                    "".join(
-                        traceback.format_exception(
-                            args.exc_type, args.exc_value, args.exc_tb
-                        )
-                    ),
-                )
-                if self._prev_thread_excepthook:
-                    self._prev_thread_excepthook(args)
-
-            threading.excepthook = _thread_excepthook
-
-    def disable(self) -> None:
-        if not self._enabled:
-            return
-        self._enabled = False
-
-        if self._prev_excepthook is not None:
-            sys.excepthook = self._prev_excepthook
-            self._prev_excepthook = None
-
-        if hasattr(threading, "excepthook") and self._prev_thread_excepthook is not None:
-            threading.excepthook = self._prev_thread_excepthook
-            self._prev_thread_excepthook = None
-
-    def is_enabled(self) -> bool:
-        return self._enabled
-
-    def track_error(
-        self,
-        error: Exception,
-        error_type: Optional[str] = None,
-        severity: str = "error",
-        distinct_id: str = "server_global",
-    ) -> None:
-        self._track_error(
-            error_type or type(error).__name__,
-            str(error),
-            traceback.format_exc() or repr(error),
-            severity=severity,
-            distinct_id=distinct_id,
-        )
-
-    def _track_error(
-        self,
-        error_type: str,
-        message: str,
-        stack: str,
-        severity: str = "critical",
-        distinct_id: str = "server_global",
-    ) -> None:
-        try:
-            session = self._session_manager.get_or_create(distinct_id, self._site_id)
-            self._session_manager.ensure_confirmed(session, self._http)
-
-            event = EventPayload(
-                event_type="auto",
-                event_name="server_error",
-                event_category="error",
-                session_id=session.session_id,
-                user_id=session.distinct_id,
-                custom_properties={
-                    "error_type": error_type,
-                    "message": message,
-                    "stack": stack,
-                    "runtime": "python",
-                    "severity": severity,
-                    "timestamp": _now_iso(),
-                },
-            )
-            self._http.post_event(event)
-        except Exception:
-            pass  # Never let error tracking crash the process
+"""Auto event manager — captures unhandled Python exceptions as server_error events."""
+
+from __future__ import annotations
+
+import sys
+import threading
+import traceback
+from datetime import datetime, timezone
+from typing import Any, Optional, TYPE_CHECKING
+
+from ..types import EventPayload
+
+if TYPE_CHECKING:
+    from ..session.session_manager import SessionManager
+    from ..api.http_client import HttpClient
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class AutoEventManager:
+    def __init__(
+        self,
+        site_id: str,
+        http_client: "HttpClient",
+        session_manager: "SessionManager",
+    ) -> None:
+        self._site_id = site_id
+        self._http = http_client
+        self._session_manager = session_manager
+        self._enabled = False
+        self._prev_excepthook: Any = None
+        self._prev_thread_excepthook: Any = None
+
+    def enable(self) -> None:
+        if self._enabled:
+            return
+        self._enabled = True
+
+        # Wrap sys.excepthook
+        self._prev_excepthook = sys.excepthook
+
+        def _excepthook(exc_type, exc_value, exc_tb):
+            self._track_error(
+                exc_type.__name__ if exc_type else "Exception",
+                str(exc_value),
+                "".join(traceback.format_exception(exc_type, exc_value, exc_tb)),
+            )
+            if self._prev_excepthook:
+                self._prev_excepthook(exc_type, exc_value, exc_tb)
+
+        sys.excepthook = _excepthook
+
+        # Wrap threading.excepthook (Python 3.8+)
+        if hasattr(threading, "excepthook"):
+            self._prev_thread_excepthook = threading.excepthook
+
+            def _thread_excepthook(args):
+                self._track_error(
+                    args.exc_type.__name__ if args.exc_type else "ThreadException",
+                    str(args.exc_value),
+                    "".join(
+                        traceback.format_exception(
+                            args.exc_type, args.exc_value, args.exc_tb
+                        )
+                    ),
+                )
+                if self._prev_thread_excepthook:
+                    self._prev_thread_excepthook(args)
+
+            threading.excepthook = _thread_excepthook
+
+    def disable(self) -> None:
+        if not self._enabled:
+            return
+        self._enabled = False
+
+        if self._prev_excepthook is not None:
+            sys.excepthook = self._prev_excepthook
+            self._prev_excepthook = None
+
+        if hasattr(threading, "excepthook") and self._prev_thread_excepthook is not None:
+            threading.excepthook = self._prev_thread_excepthook
+            self._prev_thread_excepthook = None
+
+    def is_enabled(self) -> bool:
+        return self._enabled
+
+    def track_error(
+        self,
+        error: Exception,
+        error_type: Optional[str] = None,
+        severity: str = "error",
+        distinct_id: str = "server_global",
+    ) -> None:
+        self._track_error(
+            error_type or type(error).__name__,
+            str(error),
+            traceback.format_exc() or repr(error),
+            severity=severity,
+            distinct_id=distinct_id,
+        )
+
+    def _track_error(
+        self,
+        error_type: str,
+        message: str,
+        stack: str,
+        severity: str = "critical",
+        distinct_id: str = "server_global",
+    ) -> None:
+        try:
+            session = self._session_manager.get_or_create(distinct_id, self._site_id)
+            self._session_manager.ensure_confirmed(session, self._http)
+
+            event = EventPayload(
+                event_type="auto",
+                event_name="server_error",
+                event_category="error",
+                session_id=session.session_id,
+                user_id=session.distinct_id,
+                custom_properties={
+                    "error_type": error_type,
+                    "message": message,
+                    "stack": stack,
+                    "runtime": "python",
+                    "severity": severity,
+                    "timestamp": _now_iso(),
+                },
+            )
+            self._http.post_event(event)
+        except Exception:
+            pass  # Never let error tracking crash the process