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

trodo/managers/group_manager.py

@@ -1,106 +1,106 @@
-"""Group management methods and GroupProfile proxy."""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Dict, List, Optional, Union
-
-from ..api import endpoints
-from ..types import ApiResult
-
-
-class GroupProfile:
-    def __init__(
-        self,
-        http_client: object,
-        site_id: str,
-        distinct_id: str,
-        group_key: str,
-        group_id: str,
-    ) -> None:
-        self._http = http_client
-        self._site_id = site_id
-        self._distinct_id = distinct_id
-        self._group_key = group_key
-        self._group_id = group_id
-
-    def _base(self) -> Dict[str, Any]:
-        return {
-            "siteId": self._site_id,
-            "userId": self._distinct_id,
-            "groupKey": self._group_key,
-            "groupId": self._group_id,
-        }
-
-    def _call(self, method: str, extra: Optional[Dict[str, Any]] = None) -> ApiResult:
-        payload = {**self._base(), **(extra or {})}
-        return self._http.post_group(  # type: ignore[attr-defined]
-            f"{endpoints.GROUPS_PROFILE}/{method}", payload
-        )
-
-    def set(self, properties: Dict[str, Any]) -> ApiResult:
-        return self._call("set", {"properties": properties})
-
-    def set_once(self, properties: Dict[str, Any]) -> ApiResult:
-        return self._call("set_once", {"properties": properties})
-
-    def union(self, list_name: str, values: List[Any]) -> ApiResult:
-        return self._call("union", {"listName": list_name, "values": values})
-
-    def remove(self, list_name: str, value: Any) -> ApiResult:
-        return self._call("remove", {"listName": list_name, "value": value})
-
-    def unset(self, property: str) -> ApiResult:
-        return self._call("unset", {"property": property})
-
-    def increment(self, property: str, value: float = 1) -> ApiResult:
-        return self._call("increment", {"property": property, "value": value})
-
-    def append(self, property: str, value: Any) -> ApiResult:
-        return self._call("append", {"property": property, "value": value})
-
-    def delete(self) -> ApiResult:
-        return self._call("delete")
-
-
-class GroupManager:
-    def __init__(
-        self,
-        http_client: object,
-        site_id: str,
-        get_distinct_id: Callable[[], str],
-    ) -> None:
-        self._http = http_client
-        self._site_id = site_id
-        self._get_distinct_id = get_distinct_id
-
-    def _base(self) -> Dict[str, Any]:
-        return {"siteId": self._site_id, "userId": self._get_distinct_id()}
-
-    def set_group(
-        self, group_key: str, group_id: Union[str, List[str]]
-    ) -> ApiResult:
-        return self._http.post_group(  # type: ignore[attr-defined]
-            endpoints.GROUPS_SET,
-            {**self._base(), "groupKey": group_key, "groupId": group_id},
-        )
-
-    def add_group(self, group_key: str, group_id: str) -> ApiResult:
-        return self._http.post_group(  # type: ignore[attr-defined]
-            endpoints.GROUPS_ADD,
-            {**self._base(), "groupKey": group_key, "groupId": group_id},
-        )
-
-    def remove_group(self, group_key: str, group_id: str) -> ApiResult:
-        return self._http.post_group(  # type: ignore[attr-defined]
-            endpoints.GROUPS_REMOVE,
-            {**self._base(), "groupKey": group_key, "groupId": group_id},
-        )
-
-    def get_group(self, group_key: str, group_id: str) -> GroupProfile:
-        return GroupProfile(
-            self._http,
-            self._site_id,
-            self._get_distinct_id(),
-            group_key,
-            group_id,
-        )
+"""Group management methods and GroupProfile proxy."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from ..api import endpoints
+from ..types import ApiResult
+
+
+class GroupProfile:
+    def __init__(
+        self,
+        http_client: object,
+        site_id: str,
+        distinct_id: str,
+        group_key: str,
+        group_id: str,
+    ) -> None:
+        self._http = http_client
+        self._site_id = site_id
+        self._distinct_id = distinct_id
+        self._group_key = group_key
+        self._group_id = group_id
+
+    def _base(self) -> Dict[str, Any]:
+        return {
+            "siteId": self._site_id,
+            "userId": self._distinct_id,
+            "groupKey": self._group_key,
+            "groupId": self._group_id,
+        }
+
+    def _call(self, method: str, extra: Optional[Dict[str, Any]] = None) -> ApiResult:
+        payload = {**self._base(), **(extra or {})}
+        return self._http.post_group(  # type: ignore[attr-defined]
+            f"{endpoints.GROUPS_PROFILE}/{method}", payload
+        )
+
+    def set(self, properties: Dict[str, Any]) -> ApiResult:
+        return self._call("set", {"properties": properties})
+
+    def set_once(self, properties: Dict[str, Any]) -> ApiResult:
+        return self._call("set_once", {"properties": properties})
+
+    def union(self, list_name: str, values: List[Any]) -> ApiResult:
+        return self._call("union", {"listName": list_name, "values": values})
+
+    def remove(self, list_name: str, value: Any) -> ApiResult:
+        return self._call("remove", {"listName": list_name, "value": value})
+
+    def unset(self, property: str) -> ApiResult:
+        return self._call("unset", {"property": property})
+
+    def increment(self, property: str, value: float = 1) -> ApiResult:
+        return self._call("increment", {"property": property, "value": value})
+
+    def append(self, property: str, value: Any) -> ApiResult:
+        return self._call("append", {"property": property, "value": value})
+
+    def delete(self) -> ApiResult:
+        return self._call("delete")
+
+
+class GroupManager:
+    def __init__(
+        self,
+        http_client: object,
+        site_id: str,
+        get_distinct_id: Callable[[], str],
+    ) -> None:
+        self._http = http_client
+        self._site_id = site_id
+        self._get_distinct_id = get_distinct_id
+
+    def _base(self) -> Dict[str, Any]:
+        return {"siteId": self._site_id, "userId": self._get_distinct_id()}
+
+    def set_group(
+        self, group_key: str, group_id: Union[str, List[str]]
+    ) -> ApiResult:
+        return self._http.post_group(  # type: ignore[attr-defined]
+            endpoints.GROUPS_SET,
+            {**self._base(), "groupKey": group_key, "groupId": group_id},
+        )
+
+    def add_group(self, group_key: str, group_id: str) -> ApiResult:
+        return self._http.post_group(  # type: ignore[attr-defined]
+            endpoints.GROUPS_ADD,
+            {**self._base(), "groupKey": group_key, "groupId": group_id},
+        )
+
+    def remove_group(self, group_key: str, group_id: str) -> ApiResult:
+        return self._http.post_group(  # type: ignore[attr-defined]
+            endpoints.GROUPS_REMOVE,
+            {**self._base(), "groupKey": group_key, "groupId": group_id},
+        )
+
+    def get_group(self, group_key: str, group_id: str) -> GroupProfile:
+        return GroupProfile(
+            self._http,
+            self._site_id,
+            self._get_distinct_id(),
+            group_key,
+            group_id,
+        )

trodo/managers/people_manager.py

@@ -1,77 +1,77 @@
-"""People (user profile) methods."""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Dict, List, Optional, Union
-
-from ..api import endpoints
-from ..types import ApiResult
-
-
-class PeopleManager:
-    def __init__(
-        self,
-        http_client: object,
-        site_id: str,
-        get_distinct_id: Callable[[], str],
-    ) -> None:
-        self._http = http_client
-        self._site_id = site_id
-        self._get_distinct_id = get_distinct_id
-
-    def _base(self) -> Dict[str, Any]:
-        return {"siteId": self._site_id, "userId": self._get_distinct_id()}
-
-    def set(self, properties: Dict[str, Any]) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_SET, {**self._base(), "properties": properties}
-        )
-
-    def set_once(self, properties: Dict[str, Any]) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_SET_ONCE, {**self._base(), "properties": properties}
-        )
-
-    def unset(self, keys: Union[str, List[str]]) -> ApiResult:
-        k = [keys] if isinstance(keys, str) else keys
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_UNSET, {**self._base(), "keys": k}
-        )
-
-    def increment(self, key: str, amount: float = 1) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_INCREMENT, {**self._base(), "key": key, "amount": amount}
-        )
-
-    def append(self, key: str, values: List[Any]) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_APPEND, {**self._base(), "key": key, "values": values}
-        )
-
-    def union(self, key: str, values: List[Any]) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_UNION, {**self._base(), "key": key, "values": values}
-        )
-
-    def remove(self, key: str, values: List[Any]) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_REMOVE, {**self._base(), "key": key, "values": values}
-        )
-
-    def track_charge(
-        self, amount: float, properties: Optional[Dict[str, Any]] = None
-    ) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_TRACK_CHARGE,
-            {**self._base(), "amount": amount, "properties": properties or {}},
-        )
-
-    def clear_charges(self) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_CLEAR_CHARGES, self._base()
-        )
-
-    def delete_user(self) -> ApiResult:
-        return self._http.post_people(  # type: ignore[attr-defined]
-            endpoints.PEOPLE_DELETE_USER, self._base()
-        )
+"""People (user profile) methods."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from ..api import endpoints
+from ..types import ApiResult
+
+
+class PeopleManager:
+    def __init__(
+        self,
+        http_client: object,
+        site_id: str,
+        get_distinct_id: Callable[[], str],
+    ) -> None:
+        self._http = http_client
+        self._site_id = site_id
+        self._get_distinct_id = get_distinct_id
+
+    def _base(self) -> Dict[str, Any]:
+        return {"siteId": self._site_id, "userId": self._get_distinct_id()}
+
+    def set(self, properties: Dict[str, Any]) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_SET, {**self._base(), "properties": properties}
+        )
+
+    def set_once(self, properties: Dict[str, Any]) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_SET_ONCE, {**self._base(), "properties": properties}
+        )
+
+    def unset(self, keys: Union[str, List[str]]) -> ApiResult:
+        k = [keys] if isinstance(keys, str) else keys
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_UNSET, {**self._base(), "keys": k}
+        )
+
+    def increment(self, key: str, amount: float = 1) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_INCREMENT, {**self._base(), "key": key, "amount": amount}
+        )
+
+    def append(self, key: str, values: List[Any]) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_APPEND, {**self._base(), "key": key, "values": values}
+        )
+
+    def union(self, key: str, values: List[Any]) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_UNION, {**self._base(), "key": key, "values": values}
+        )
+
+    def remove(self, key: str, values: List[Any]) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_REMOVE, {**self._base(), "key": key, "values": values}
+        )
+
+    def track_charge(
+        self, amount: float, properties: Optional[Dict[str, Any]] = None
+    ) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_TRACK_CHARGE,
+            {**self._base(), "amount": amount, "properties": properties or {}},
+        )
+
+    def clear_charges(self) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_CLEAR_CHARGES, self._base()
+        )
+
+    def delete_user(self) -> ApiResult:
+        return self._http.post_people(  # type: ignore[attr-defined]
+            endpoints.PEOPLE_DELETE_USER, self._base()
+        )

trodo/queue/batch_flusher.py

@@ -1,52 +1,52 @@
-"""Background timer-based batch flusher."""
-
-from __future__ import annotations
-
-import threading
-from typing import Optional
-
-from .event_queue import EventQueue
-
-
-class BatchFlusher:
-    def __init__(
-        self,
-        queue: EventQueue,
-        http_client: object,
-        flush_interval: float,
-    ) -> None:
-        self._queue = queue
-        self._http = http_client
-        self._flush_interval = flush_interval
-        self._timer: Optional[threading.Timer] = None
-        self._lock = threading.Lock()
-
-    def start(self) -> None:
-        self._reschedule()
-
-    def stop(self) -> None:
-        with self._lock:
-            if self._timer:
-                self._timer.cancel()
-                self._timer = None
-
-    def flush(self) -> None:
-        events = self._queue.drain()
-        if not events:
-            return
-        self._http.post_bulk_events(events)  # type: ignore[attr-defined]
-
-    def _reschedule(self) -> None:
-        with self._lock:
-            if self._timer:
-                self._timer.cancel()
-            t = threading.Timer(self._flush_interval, self._tick)
-            t.daemon = True
-            t.start()
-            self._timer = t
-
-    def _tick(self) -> None:
-        try:
-            self.flush()
-        finally:
-            self._reschedule()
+"""Background timer-based batch flusher."""
+
+from __future__ import annotations
+
+import threading
+from typing import Optional
+
+from .event_queue import EventQueue
+
+
+class BatchFlusher:
+    def __init__(
+        self,
+        queue: EventQueue,
+        http_client: object,
+        flush_interval: float,
+    ) -> None:
+        self._queue = queue
+        self._http = http_client
+        self._flush_interval = flush_interval
+        self._timer: Optional[threading.Timer] = None
+        self._lock = threading.Lock()
+
+    def start(self) -> None:
+        self._reschedule()
+
+    def stop(self) -> None:
+        with self._lock:
+            if self._timer:
+                self._timer.cancel()
+                self._timer = None
+
+    def flush(self) -> None:
+        events = self._queue.drain()
+        if not events:
+            return
+        self._http.post_bulk_events(events)  # type: ignore[attr-defined]
+
+    def _reschedule(self) -> None:
+        with self._lock:
+            if self._timer:
+                self._timer.cancel()
+            t = threading.Timer(self._flush_interval, self._tick)
+            t.daemon = True
+            t.start()
+            self._timer = t
+
+    def _tick(self) -> None:
+        try:
+            self.flush()
+        finally:
+            self._reschedule()

trodo/queue/event_queue.py

@@ -1,32 +1,32 @@
-"""Thread-safe in-memory event queue."""
-
-from __future__ import annotations
-
-import threading
-from typing import List
-
-from ..types import EventPayload
-
-
-class EventQueue:
-    def __init__(self, max_size: int = 500) -> None:
-        self._max_size = max_size
-        self._queue: List[EventPayload] = []
-        self._lock = threading.Lock()
-
-    def enqueue(self, event: EventPayload) -> bool:
-        """Returns True if flush threshold reached."""
-        with self._lock:
-            self._queue.append(event)
-            return len(self._queue) >= self._max_size
-
-    def drain(self) -> List[EventPayload]:
-        """Atomically take all queued events."""
-        with self._lock:
-            events = list(self._queue)
-            self._queue.clear()
-            return events
-
-    def size(self) -> int:
-        with self._lock:
-            return len(self._queue)
+"""Thread-safe in-memory event queue."""
+
+from __future__ import annotations
+
+import threading
+from typing import List
+
+from ..types import EventPayload
+
+
+class EventQueue:
+    def __init__(self, max_size: int = 500) -> None:
+        self._max_size = max_size
+        self._queue: List[EventPayload] = []
+        self._lock = threading.Lock()
+
+    def enqueue(self, event: EventPayload) -> bool:
+        """Returns True if flush threshold reached."""
+        with self._lock:
+            self._queue.append(event)
+            return len(self._queue) >= self._max_size
+
+    def drain(self) -> List[EventPayload]:
+        """Atomically take all queued events."""
+        with self._lock:
+            events = list(self._queue)
+            self._queue.clear()
+            return events
+
+    def size(self) -> int:
+        with self._lock:
+            return len(self._queue)