lucidicai 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

lucidicai/utils/queue.py

@@ -0,0 +1,393 @@
+"""Parallel event queue for efficient event processing.
+
+This module provides a high-performance event queue that processes events
+in parallel while respecting parent-child dependencies.
+"""
+import gzip
+import io
+import json
+import queue
+import threading
+import time
+import requests
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from ..core.config import get_config
+from ..utils.logger import debug, info, warning, error, truncate_id, truncate_data
+
+
+class EventQueue:
+    """High-performance parallel event queue."""
+    
+    def __init__(self, client):
+        """Initialize the event queue."""
+        self.config = get_config()
+        self._client = client
+        
+        # Queue configuration
+        self.max_queue_size = self.config.event_queue.max_queue_size
+        self.flush_interval_ms = self.config.event_queue.flush_interval_ms
+        self.flush_at_count = self.config.event_queue.flush_at_count
+        self.blob_threshold = self.config.event_queue.blob_threshold
+        self.max_workers = self.config.event_queue.max_parallel_workers
+        self.retry_failed = self.config.event_queue.retry_failed
+        
+        # Runtime state
+        self._queue = queue.Queue(maxsize=self.max_queue_size)
+        self._stopped = threading.Event()
+        self._flush_event = threading.Event()
+        self._worker: Optional[threading.Thread] = None
+        self._sent_ids: Set[str] = set()
+        # Removed deferred queue - no longer needed since backend handles any order
+        
+        # Thread pool for parallel processing
+        self._executor = ThreadPoolExecutor(
+            max_workers=self.max_workers,
+            thread_name_prefix="LucidicSender"
+        )
+        
+        # Thread safety
+        self._flush_lock = threading.Lock()
+        self._processing_count = 0
+        self._processing_lock = threading.Lock()
+        
+        # Start background worker
+        self._start_worker()
+        
+        debug(f"[EventQueue] Initialized with {self.max_workers} parallel workers, batch size: {self.flush_at_count}, flush interval: {self.flush_interval_ms}ms")
+
+    def queue_event(self, event_request: Dict[str, Any]) -> None:
+        """Enqueue an event for background processing."""
+        if "defer_count" not in event_request:
+            event_request["defer_count"] = 0
+        
+        try:
+            self._queue.put(event_request, block=True, timeout=0.001)
+            
+            event_id = event_request.get('client_event_id', 'unknown')
+            parent_id = event_request.get('client_parent_event_id')
+            debug(f"[EventQueue] Queued event {truncate_id(event_id)} (parent: {truncate_id(parent_id)}), queue size: {self._queue.qsize()}")
+            
+            # Wake worker if batch large enough
+            if self._queue.qsize() >= self.flush_at_count:
+                self._flush_event.set()
+                
+        except queue.Full:
+            warning(f"[EventQueue] Queue at max size {self.max_queue_size}, dropping event")
+
+    def force_flush(self, timeout_seconds: float = 5.0) -> None:
+        """Flush current queue synchronously (best-effort)."""
+        with self._flush_lock:
+            debug(f"[EventQueue] Force flush requested, queue size: {self._queue.qsize()}")
+            
+            # Signal the worker to flush immediately
+            self._flush_event.set()
+            
+            # Wait for the queue to be processed
+            end_time = time.time() + timeout_seconds
+            last_size = -1
+            stable_count = 0
+            
+            debug(f"[EventQueue] Force flush: entering wait loop, timeout={timeout_seconds}s")
+            iterations = 0
+            start_time = time.time()
+            while time.time() < end_time:
+                iterations += 1
+                if iterations % 20 == 1:  # Log every second (20 * 0.05s)
+                    debug(f"[EventQueue] Force flush: iteration {iterations}, time left: {end_time - time.time():.1f}s")
+                
+                current_size = self._queue.qsize()
+                
+                with self._processing_lock:
+                    processing = self._processing_count
+                
+                # Check if we're done
+                if current_size == 0 and processing == 0:
+                    if stable_count >= 2:
+                        debug("[EventQueue] Force flush complete")
+                        return
+                    stable_count += 1
+                    debug(f"[EventQueue] Force flush: queue empty, stable_count={stable_count}")
+                else:
+                    stable_count = 0
+                
+                # Check for progress
+                if current_size == last_size:
+                    stable_count += 1
+                    if stable_count >= 10:  # 0.5 seconds of no progress
+                        break
+                else:
+                    stable_count = 0
+                    last_size = current_size
+                
+                self._flush_event.set()
+                time.sleep(0.05)
+                
+                # Safety check to prevent infinite loop
+                if time.time() - start_time > timeout_seconds + 1:
+                    warning(f"[EventQueue] Force flush: exceeded timeout by >1s, breaking")
+                    break
+            
+            debug(f"[EventQueue] Force flush: exited wait loop after {time.time() - start_time:.1f}s")
+
+    def is_empty(self) -> bool:
+        """Check if queue is completely empty."""
+        with self._processing_lock:
+            queue_empty = self._queue.empty()
+            not_processing = self._processing_count == 0
+        # No deferred queue to check anymore
+        return queue_empty and not_processing
+
+    def shutdown(self, timeout: float = 5.0) -> None:
+        """Shutdown the event queue."""
+        info(f"[EventQueue] Shutting down with {self._queue.qsize()} events in queue")
+        
+        # Flush remaining events
+        self.force_flush(timeout_seconds=timeout)
+        
+        # Shutdown executor (timeout param added in Python 3.9+)
+        try:
+            self._executor.shutdown(wait=True, timeout=timeout)
+        except TypeError:
+            # Fallback for older Python versions
+            self._executor.shutdown(wait=True)
+        
+        # Signal stop
+        self._stopped.set()
+        self._flush_event.set()
+        
+        # Wait for worker
+        if self._worker and self._worker.is_alive():
+            self._worker.join(timeout=timeout)
+
+    # --- Internal Implementation ---
+    
+    def _start_worker(self) -> None:
+        """Start the background worker thread."""
+        if self._worker and self._worker.is_alive():
+            return
+        
+        self._worker = threading.Thread(
+            target=self._run_loop,
+            name="LucidicEventQueue",
+            daemon=self.config.event_queue.daemon_mode
+        )
+        self._worker.start()
+
+    def _run_loop(self) -> None:
+        """Main worker loop."""
+        while not self._stopped.is_set():
+            batch = self._collect_batch()
+            
+            if batch:
+                with self._processing_lock:
+                    self._processing_count = len(batch)
+                
+                try:
+                    self._process_batch(batch)
+                except Exception as e:
+                    error(f"[EventQueue] Batch processing error: {e}")
+                finally:
+                    with self._processing_lock:
+                        self._processing_count = 0
+
+    def _collect_batch(self) -> List[Dict[str, Any]]:
+        """Collect a batch of events from the queue."""
+        batch: List[Dict[str, Any]] = []
+        deadline = time.time() + (self.flush_interval_ms / 1000.0)
+        
+        while True:
+            # Check for force flush
+            if self._flush_event.is_set():
+                self._flush_event.clear()
+                # Drain entire queue
+                while not self._queue.empty():
+                    try:
+                        batch.append(self._queue.get_nowait())
+                    except queue.Empty:
+                        break
+                if batch:
+                    break
+            
+            # Check batch size
+            if len(batch) >= self.flush_at_count:
+                break
+            
+            # Check deadline
+            remaining_time = deadline - time.time()
+            if remaining_time <= 0:
+                break
+            
+            # Try to get an item
+            try:
+                timeout = min(remaining_time, 0.05)
+                item = self._queue.get(block=True, timeout=timeout)
+                batch.append(item)
+            except queue.Empty:
+                if self._stopped.is_set():
+                    # Drain remaining on shutdown
+                    while not self._queue.empty():
+                        try:
+                            batch.append(self._queue.get_nowait())
+                        except queue.Empty:
+                            break
+                    break
+                if batch and time.time() >= deadline:
+                    break
+        
+        return batch
+
+    def _process_batch(self, batch: List[Dict[str, Any]]) -> None:
+        """Process batch with parallel sending."""
+        debug(f"[EventQueue] Processing batch of {len(batch)} events")
+        
+        # No need to handle deferred events - we don't defer anymore
+        
+        # Group for parallel processing
+        dependency_groups = self._group_by_dependencies(batch)
+        
+        # Process each group in parallel
+        for group_index, group in enumerate(dependency_groups):
+            debug(f"[EventQueue] Processing dependency group {group_index + 1}/{len(dependency_groups)} with {len(group)} events in parallel")
+            
+            # Submit all events in group for parallel processing
+            futures_to_event = {}
+            for event in group:
+                future = self._executor.submit(self._send_event_safe, event)
+                futures_to_event[future] = event
+            
+            # Wait for completion
+            for future in as_completed(futures_to_event):
+                event = futures_to_event[future]
+                try:
+                    success = future.result(timeout=30)
+                    if success:
+                        if event_id := event.get("client_event_id"):
+                            self._sent_ids.add(event_id)
+                except Exception as e:
+                    debug(f"[EventQueue] Failed to send event: {e}")
+                    if self.retry_failed:
+                        self._retry_event(event)
+
+    def _group_by_dependencies(self, events: List[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
+        """Group events for parallel processing.
+        
+        Since the backend handles events in any order using client-side event IDs,
+        we don't need to check dependencies. Just return all events in one group
+        for maximum parallel processing.
+        """
+        if not events:
+            return []
+        
+        # Mark all event IDs as sent for tracking
+        for event in events:
+            if event_id := event.get("client_event_id"):
+                self._sent_ids.add(event_id)
+        
+        # Return all events in a single group for parallel processing
+        return [events]
+
+    def _send_event_safe(self, event_request: Dict[str, Any]) -> bool:
+        """Send event with error suppression if configured."""
+        if self.config.error_handling.suppress_errors:
+            try:
+                return self._send_event(event_request)
+            except Exception as e:
+                warning(f"[EventQueue] Suppressed send error: {e}")
+                return False
+        else:
+            return self._send_event(event_request)
+
+    def _send_event(self, event_request: Dict[str, Any]) -> bool:
+        """Send a single event to the backend."""
+        # No dependency checking needed - backend handles events in any order
+        
+        # Check for blob offloading
+        payload = event_request.get("payload", {})
+        raw_bytes = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+        should_offload = len(raw_bytes) > self.blob_threshold
+        
+        if should_offload:
+            event_id = event_request.get('client_event_id', 'unknown')
+            debug(f"[EventQueue] Event {truncate_id(event_id)} needs blob storage ({len(raw_bytes)} bytes > {self.blob_threshold} threshold)")
+        
+        send_body: Dict[str, Any] = dict(event_request)
+        if should_offload:
+            send_body["needs_blob"] = True
+            send_body["payload"] = self._create_preview(send_body.get("type"), payload)
+        else:
+            send_body["needs_blob"] = False
+        
+        # Send event
+        try:
+            response = self._client.make_request("events", "POST", send_body)
+            
+            # Handle blob upload if needed
+            if should_offload:
+                blob_url = response.get("blob_url")
+                if blob_url:
+                    compressed = self._compress_json(payload)
+                    self._upload_blob(blob_url, compressed)
+                    debug(f"[EventQueue] Blob uploaded for event {truncate_id(event_request.get('client_event_id'))}")
+                else:
+                    error("[EventQueue] No blob_url received for large payload")
+                    return False
+            
+            return True
+            
+        except Exception as e:
+            debug(f"[EventQueue] Failed to send event {truncate_id(event_request.get('client_event_id'))}: {e}")
+            return False
+
+    def _retry_event(self, event: Dict[str, Any]) -> None:
+        """Retry a failed event."""
+        event["retry_count"] = event.get("retry_count", 0) + 1
+        if event["retry_count"] <= 3:
+            try:
+                self._queue.put_nowait(event)
+            except queue.Full:
+                pass
+
+    @staticmethod
+    def _compress_json(payload: Dict[str, Any]) -> bytes:
+        """Compress JSON payload using gzip."""
+        raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+        buf = io.BytesIO()
+        with gzip.GzipFile(fileobj=buf, mode="wb") as gz:
+            gz.write(raw)
+        return buf.getvalue()
+
+    def _upload_blob(self, blob_url: str, data: bytes) -> None:
+        """Upload compressed blob to presigned URL."""
+        headers = {"Content-Type": "application/json", "Content-Encoding": "gzip"}
+        resp = requests.put(blob_url, data=data, headers=headers)
+        resp.raise_for_status()
+
+    @staticmethod
+    def _create_preview(event_type: Optional[str], payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Create preview of large payload for logging."""
+        try:
+            t = (event_type or "generic").lower()
+            
+            if t == "llm_generation":
+                req = payload.get("request", {})
+                return {
+                    "request": {
+                        "model": str(req.get("model", ""))[:200],
+                        "provider": str(req.get("provider", ""))[:200],
+                        "messages": "truncated"
+                    },
+                    "response": {"output": "truncated"}
+                }
+            elif t == "function_call":
+                return {
+                    "function_name": str(payload.get("function_name", ""))[:200],
+                    "arguments": "truncated"
+                }
+            else:
+                return {"details": "preview_unavailable"}
+                
+        except Exception:
+            return {"details": "preview_error"}

{lucidicai-2.0.1.dist-info → lucidicai-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lucidicai
-Version: 2.0.1
+Version: 2.1.0
 Summary: Lucidic AI Python SDK
 Author: Andy Liang
 Author-email: andy@lucidic.ai

{lucidicai-2.0.1.dist-info → lucidicai-2.1.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-lucidicai/__init__.py,sha256=3gm2pFPTndvfx1zalGWqBdbdkUE_DDvAPbtsoIV5720,35879
+lucidicai/__init__.py,sha256=qAza0IBGUQS3e-_uXzRvqVxUH7XliA5XYieTEpXnGT0,11992
 lucidicai/action.py,sha256=sPRd1hTIVXDqnvG9ZXWEipUFh0bsXcE0Fm7RVqmVccM,237
-lucidicai/client.py,sha256=dRSwOAGth_b-RRBjLuxhPI75ULpQHP7M-KfP9X-XYjY,22172
+lucidicai/client.py,sha256=IIhlY6Mfwy47FeMxzpvIygCaqcI1FnqiXiVU6M4QEiE,22327
 lucidicai/constants.py,sha256=zN8O7TjoRHRlaGa9CZUWppS73rhzKGwaEkF9XMTV0Cg,1160
 lucidicai/context.py,sha256=ruEXAndSv0gQ-YEXLlC4Fx6NNbaylfp_dZxbpwmLZSA,4622
-lucidicai/dataset.py,sha256=IgWCUhoclq1ZzSNc22UHd3fLs0hJv9A81OQizjbHtiE,3951
+lucidicai/dataset.py,sha256=wu25X02JyWkht_yQabgQpGZFfzbNTxG6tf5k9ol8Amo,4005
 lucidicai/decorators.py,sha256=obpHbGLhRd-yIL5xIqzjNmf-ZKCIIx5vlYnMpCcJ7Uo,5416
-lucidicai/errors.py,sha256=XT9UiYVoi88VsxrD2RU96l6mwCmxSeICOWhghB0iJ7Y,2058
+lucidicai/errors.py,sha256=IjnGag21aEsWryJ8hSqRMPftMeteHLQHQVZuQWl0ynM,2254
 lucidicai/event.py,sha256=ObPXS22QIB-n4eHxzEimTtrlOxC1L6_eQVUAx4ZIT7s,2089
 lucidicai/event_queue.py,sha256=7Y8hkrm0a7EGCBN2oW_XWd-GkJ9Cihnu2Gyk6FMftks,20065
-lucidicai/feature_flag.py,sha256=Hfcoqqb5VimuaY1Q0NXl08elxQWG97KqzRpaMfE4PYA,11841
+lucidicai/feature_flag.py,sha256=JRvIKUtF9d49o6L8laSg-LUfqSw-Q8QoTqin4z-wIVs,12005
 lucidicai/image_upload.py,sha256=6SRudg-BpInM2gzMx1Yf1Rz_Zyh8inwoJ7U4pBw7ruY,3807
 lucidicai/lru.py,sha256=PXiDSoUCOxjamG1QlQx6pDbQCm8h5hKAnnr_NI0PEgE,618
 lucidicai/model_pricing.py,sha256=Dxi6e0WjcIyCTkVX7K7f0pJ5rPu7nSt3lOmgzAUQl1o,12402
@@ -17,6 +17,16 @@ lucidicai/singleton.py,sha256=SKiNBgt_Wb5cCWbMt3IWjRAQw3v153LTRgqvDj8poF8,1457
 lucidicai/state.py,sha256=4Tb1X6l2or6w_e62FYSuEeghAv3xXm5gquKwzCpvdok,235
 lucidicai/step.py,sha256=_oBIyTBZBvNkUkYHIrwWd75KMSlMtR9Ws2Lo71Lyff8,2522
 lucidicai/streaming.py,sha256=QOLAzhwxetvx711J8VcphY5kXWPJz9XEBJrmHveRKMc,9796
+lucidicai/api/__init__.py,sha256=UOYuFZupG0TgzMAxbLNgpodDXhDRXBgMva8ZblgBN9Y,31
+lucidicai/api/client.py,sha256=czD3sg4wgyGQTVVlnSi3wpeCt90_D4eOuK8nBlpiv4U,7276
+lucidicai/api/resources/__init__.py,sha256=Wc8-JfL82wkE7eB8PHplqYvaEG2oXNXXhRyEPeduJeE,27
+lucidicai/api/resources/dataset.py,sha256=6UnMUd-y__TOAjUJLjbc0lZJRTy_gHkyoE82OvjFoN4,5583
+lucidicai/api/resources/event.py,sha256=GyyNL3_k53EbmvTdgJEABexiuJnoX61hxWey7DYmlYY,2434
+lucidicai/api/resources/session.py,sha256=w7b4kkbWdbaNbwuMBFgEeVmDfaYozBf9OK8B8L9B1m8,3730
+lucidicai/core/__init__.py,sha256=b0YQkd8190Y_GgwUcmf0tOiSLARd7L4kq4jwfhhGAyI,39
+lucidicai/core/config.py,sha256=m5kl9wiVp5J0DW6ES--GzsMgyykSYtaCi3D-2tW650M,7972
+lucidicai/core/errors.py,sha256=aRfdXABiTWFTiWELgu2Dz_wxVSggcBFqX7Q-toCy_fY,2130
+lucidicai/core/types.py,sha256=KabcTBQe7SemigccKfJSDiJmjSJDJJvvtefSd8pfrJI,702
 lucidicai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/providers/anthropic_handler.py,sha256=GZEa4QOrjZ9ftu_qTwY3L410HwKzkXgN7omYRsEQ4LU,10174
 lucidicai/providers/base_providers.py,sha256=nrZVr4Y9xcAiMn4uAN3t3k6DlHNTvlXrA4qQg7lANOQ,544
@@ -34,12 +44,24 @@ lucidicai/providers/otel_provider.py,sha256=ixLc80-_Vag0EO_92wj2m3_lg6HXyIpz9Md4
 lucidicai/providers/pydantic_ai_handler.py,sha256=Yhd9VTJhq292ZzJF04O_jYGRh-1bzs70BzQdo7a2Z9M,28269
 lucidicai/providers/text_storage.py,sha256=L62MMJ8E23TDqDTUv2aRntdKMCItsXV7XjY6cFwx2DE,1503
 lucidicai/providers/universal_image_interceptor.py,sha256=7d-hw4xihRwvvA1AP8-vqYNChtmVXKmn09MN4pDS7KQ,12126
+lucidicai/sdk/__init__.py,sha256=UrkV9FYbZkBxaX9qwxGbCJdXp-JqMpn0_u-huO9Y-ec,32
+lucidicai/sdk/context.py,sha256=ruEXAndSv0gQ-YEXLlC4Fx6NNbaylfp_dZxbpwmLZSA,4622
+lucidicai/sdk/decorators.py,sha256=B5BXG9Sn5ruUkxFq10L1rrCR_wzYUPlYeu5aqyXetMM,8393
+lucidicai/sdk/error_boundary.py,sha256=IPr5wS9rS7ZQNgEaBwK53UaixAm6L2rijKKFfxcxjUI,9190
+lucidicai/sdk/event.py,sha256=jadK8bZ_kkpycx5zHC5tlNUqL_yCk2WJ6REuFrSrIVI,3564
+lucidicai/sdk/event_builder.py,sha256=oMvt39m07ZLmPllJTWwRxpinJUz9_AD17yNE6wQRoDA,10423
+lucidicai/sdk/init.py,sha256=gxWfK_c22BcAwnv9LZWqmS_G303_rRAhA0zt2nWKdvc,9289
+lucidicai/sdk/shutdown_manager.py,sha256=I5ylR96QHQ_SfP1euAiM0qQ-I7upCPMW1HUNvoj7hCw,12090
+lucidicai/sdk/features/__init__.py,sha256=23KUF2EZBzsaH9JUFDGNXZb_3PSfc35VZfD59gAfyR0,26
+lucidicai/sdk/features/dataset.py,sha256=qFGnu8Wm1yhaflBhtm-5veN-KaoxGLBL5xWEifkrsY0,19416
+lucidicai/sdk/features/feature_flag.py,sha256=SzuzHiVnbticD6Ojn0_i9xQKui2s9QUFPJ7LixzAtf4,13844
 lucidicai/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/telemetry/base_provider.py,sha256=nrZVr4Y9xcAiMn4uAN3t3k6DlHNTvlXrA4qQg7lANOQ,544
-lucidicai/telemetry/context_capture_processor.py,sha256=k4_uTaoOhLeUAZsyUcDExVNXadk0nR4R1hJW096EVwY,2472
+lucidicai/telemetry/context_bridge.py,sha256=NwyclZvPcZHZtIvLSrY3oO8WQ_J1JSuHWIr36gxA7xk,2989
+lucidicai/telemetry/context_capture_processor.py,sha256=kzKWpg5m0OMUP5we6g453FjckWwA_jAVjOKCfiyKVN8,3651
 lucidicai/telemetry/extract.py,sha256=30Iqvnr9I0EkD61GRCMN0Zpk3fLmRYcuVajWjRz0z9I,6814
-lucidicai/telemetry/litellm_bridge.py,sha256=CFXVu8nduBtJEhv21maNMrkXV_x5ropy--7qr6HAjh8,16542
-lucidicai/telemetry/lucidic_exporter.py,sha256=PfUB5a5o6av1YbYj52WQ-I71q8PBja3xvYTRWItFDPc,11029
+lucidicai/telemetry/litellm_bridge.py,sha256=QXUNwFI3GyvCQtnsnnSnmh2BfdnfnbKIDjfc_Rviau4,16436
+lucidicai/telemetry/lucidic_exporter.py,sha256=ghzPVGJlR3yPtRNMtnvlqcMuQCNTkU-oRLyu_YiuzQU,11892
 lucidicai/telemetry/lucidic_span_processor.py,sha256=-jo7Muuslo3ZCSAysLsDGBqJijQSpIOvJHPbPNjP4iQ,31029
 lucidicai/telemetry/openai_agents_instrumentor.py,sha256=__wIbeglMnEEf4AGTQ--FXeWCKmz2yy8SBupwprEdZA,12694
 lucidicai/telemetry/opentelemetry_converter.py,sha256=xOHCqoTyO4hUkL6k7fxy84PbljPpYep6ET9ZqbkJehc,17665
@@ -50,9 +72,14 @@ lucidicai/telemetry/pydantic_ai_handler.py,sha256=WPa3tFcVgVnPPO3AxcNOTbNkmODLgN
 lucidicai/telemetry/telemetry_init.py,sha256=8RMzZeeHYvaJKaM5KeSt0svaUAqODHmLstECjgHr8fc,8660
 lucidicai/telemetry/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lucidicai/telemetry/utils/image_storage.py,sha256=4Z59ZpVexr7-lcExfr8GsqXe0y2VZmr8Yjwa-3DeOxU,1457
+lucidicai/telemetry/utils/model_pricing.py,sha256=Dxi6e0WjcIyCTkVX7K7f0pJ5rPu7nSt3lOmgzAUQl1o,12402
 lucidicai/telemetry/utils/text_storage.py,sha256=L62MMJ8E23TDqDTUv2aRntdKMCItsXV7XjY6cFwx2DE,1503
 lucidicai/telemetry/utils/universal_image_interceptor.py,sha256=vARgMk1hVSF--zfi5b8qBpJJOESuD17YlH9xqxmB9Uw,15954
-lucidicai-2.0.1.dist-info/METADATA,sha256=DOyezEU2bp3jBJOiNkXIOOZu55NRdLXztk95jZf9rwA,902
-lucidicai-2.0.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-lucidicai-2.0.1.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
-lucidicai-2.0.1.dist-info/RECORD,,
+lucidicai/utils/__init__.py,sha256=ZiGtmJaF0ph9iIFIgQiAreVuYM_1o7qu9VySK1NblTw,22
+lucidicai/utils/images.py,sha256=YHFjeKHRxzWu0IsuNwKw303egPsd99AShaD4WND1lJk,12325
+lucidicai/utils/logger.py,sha256=R3B3gSee64F6UVHUrShihBq_O7W7bgfrBiVDXTO3Isg,4777
+lucidicai/utils/queue.py,sha256=iBhazYt9EPTpyuexfDyPjvJT-2ODaAbCBbGYvLVl8wM,15815
+lucidicai-2.1.0.dist-info/METADATA,sha256=5olKiUoS21uLWjjoOkbJaQGY1J0FDJSTKMVGmOcoTEI,902
+lucidicai-2.1.0.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+lucidicai-2.1.0.dist-info/top_level.txt,sha256=vSSdM3lclF4I5tyVC0xxUk8eIRnnYXMe1hW-eO91HUo,10
+lucidicai-2.1.0.dist-info/RECORD,,