raindrop-ai 0.0.26__tar.gz → 0.0.27__tar.gz

{raindrop_ai-0.0.26 → raindrop_ai-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: raindrop-ai
-Version: 0.0.26
+Version: 0.0.27
 Summary: Raindrop AI (Python SDK)
 License: MIT
 Author: Raindrop AI

{raindrop_ai-0.0.26 → raindrop_ai-0.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "raindrop-ai"
-version = "0.0.26"
+version = "0.0.27"
 description = "Raindrop AI (Python SDK)"
 authors = ["Raindrop AI <sdk@raindrop.ai>"]
 license = "MIT"

{raindrop_ai-0.0.26 → raindrop_ai-0.0.27}/raindrop/analytics.py

@@ -11,14 +11,24 @@ import atexit
 from pydantic import ValidationError
 from threading import Timer
 from raindrop.version import VERSION
-from raindrop.models import TrackAIEvent, Attachment, SignalEvent, DefaultSignal, FeedbackSignal, EditSignal, PartialTrackAIEvent, PartialAIData
+from raindrop.models import (
+    TrackAIEvent,
+    Attachment,
+    SignalEvent,
+    DefaultSignal,
+    FeedbackSignal,
+    EditSignal,
+    PartialTrackAIEvent,
+    PartialAIData,
+)
 from raindrop.interaction import Interaction
 from raindrop.redact import perform_pii_redaction
 
 
-
 # Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
 logger = logging.getLogger(__name__)
 
 write_key = None
@@ -36,7 +46,8 @@ max_ingest_size_bytes = 1 * 1024 * 1024  # 1 MB
 
 _partial_buffers: dict[str, PartialTrackAIEvent] = {}
 _partial_timers: dict[str, Timer] = {}
-_PARTIAL_TIMEOUT = 2  # 2 seconds 
+_PARTIAL_TIMEOUT = 2  # 2 seconds
+
 
 def set_debug_logs(value: bool):
     global debug_logs
@@ -46,6 +57,7 @@ def set_debug_logs(value: bool):
     else:
         logger.setLevel(logging.INFO)
 
+
 def set_redact_pii(value: bool):
     global redact_pii
     redact_pii = value
@@ -54,6 +66,7 @@ def set_redact_pii(value: bool):
     else:
         logger.info("PII redaction disabled")
 
+
 def start_flush_thread():
     logger.debug("Opening flush thread")
     global flush_thread
@@ -62,6 +75,7 @@ def start_flush_thread():
         flush_thread.daemon = True
         flush_thread.start()
 
+
 def flush_loop():
     while not shutdown_event.is_set():
         try:
@@ -70,6 +84,7 @@ def flush_loop():
             logger.error(f"Error in flush loop: {e}")
         time.sleep(upload_interval)
 
+
 def flush() -> None:
     global buffer
 
@@ -95,14 +110,17 @@ def flush() -> None:
 
     for endpoint, events_data in grouped_events.items():
         for i in range(0, len(events_data), upload_size):
-            batch = events_data[i:i+upload_size]
+            batch = events_data[i : i + upload_size]
             logger.debug(f"Sending {len(batch)} events to {endpoint}")
             send_request(endpoint, batch)
 
     logger.debug("Flush complete")
 
-def send_request(endpoint: str, data_entries: List[Dict[str, Union[str, Dict]]]) -> None:
-    
+
+def send_request(
+    endpoint: str, data_entries: List[Dict[str, Union[str, Dict]]]
+) -> None:
+
     url = f"{api_url}{endpoint}"
     headers = {
         "Content-Type": "application/json",
@@ -117,15 +135,20 @@ def send_request(endpoint: str, data_entries: List[Dict[str, Union[str, Dict]]])
             logger.debug(f"Request successful: {response.status_code}")
             break
         except requests.exceptions.RequestException as e:
-            logger.error(f"Error sending request (attempt {attempt + 1}/{max_retries}): {e}")
+            logger.error(
+                f"Error sending request (attempt {attempt + 1}/{max_retries}): {e}"
+            )
             if attempt == max_retries - 1:
                 logger.error(f"Failed to send request after {max_retries} attempts")
 
+
 def save_to_buffer(event: Dict[str, Union[str, Dict]]) -> None:
     global buffer
 
     if len(buffer) >= max_queue_size * 0.8:
-        logger.warning(f"Buffer is at {len(buffer) / max_queue_size * 100:.2f}% capacity")
+        logger.warning(
+            f"Buffer is at {len(buffer) / max_queue_size * 100:.2f}% capacity"
+        )
 
     if len(buffer) >= max_queue_size:
         logger.error("Buffer is full. Discarding event.")
@@ -138,6 +161,7 @@ def save_to_buffer(event: Dict[str, Union[str, Dict]]) -> None:
 
     start_flush_thread()
 
+
 def identify(user_id: str, traits: Dict[str, Union[str, int, bool, float]]) -> None:
     if not _check_write_key():
         return
@@ -159,7 +183,7 @@ def track_ai(
 ) -> str:
     if not _check_write_key():
         return
-    
+
     event_id = event_id or str(uuid.uuid4())
 
     try:
@@ -169,7 +193,7 @@ def track_ai(
             event=event,
             timestamp=timestamp or _get_timestamp(),
             properties=properties or {},
-            ai_data=dict(          # Pydantic will coerce to AIData
+            ai_data=dict(  # Pydantic will coerce to AIData
                 model=model,
                 input=input,
                 output=output,
@@ -181,13 +205,12 @@ def track_ai(
         logger.error(f"[raindrop] Invalid data passed to track_ai: {err}")
         return None
 
-
     if payload.properties is None:
         payload.properties = {}
     payload.properties["$context"] = _get_context()
 
     data = payload.model_dump(mode="json")
-    
+
     # Apply PII redaction if enabled
     if redact_pii:
         data = perform_pii_redaction(data)
@@ -203,22 +226,27 @@ def track_ai(
     save_to_buffer({"type": "events/track", "data": data})
     return event_id
 
+
 def shutdown():
     logger.info("Shutting down raindrop analytics")
     for eid in list(_partial_timers.keys()):
-        _flush_partial_event(eid) 
+        _flush_partial_event(eid)
 
     shutdown_event.set()
     if flush_thread:
         flush_thread.join(timeout=10)
     flush()  # Final flush to ensure all events are sent
 
+
 def _check_write_key():
     if write_key is None:
-        logger.warning("write_key is not set. Please set it before using raindrop analytics.")
+        logger.warning(
+            "write_key is not set. Please set it before using raindrop analytics."
+        )
         return False
     return True
 
+
 def _get_context():
     return {
         "library": {
@@ -230,6 +258,7 @@ def _get_context():
         },
     }
 
+
 def _get_timestamp():
     return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
 
@@ -238,14 +267,16 @@ def _get_size(event: dict[str, any]) -> int:
     try:
         # Add default=str to handle types like datetime
         data = json.dumps(event, default=str)
-        return len(data.encode('utf-8'))
+        return len(data.encode("utf-8"))
     except (TypeError, OverflowError) as e:
         logger.error(f"Error serializing event for size calculation: {e}")
-        return 0 
+        return 0
+
 
 # Signal types - This is now defined in models.py
 # SignalType = Literal["default", "feedback", "edit"]
 
+
 def track_signal(
     event_id: str,
     name: str,
@@ -278,11 +309,15 @@ def track_signal(
     final_properties = properties.copy() if properties else {}
     if signal_type == "feedback" and comment is not None:
         if "comment" in final_properties:
-             logger.warning("'comment' provided as both argument and in properties; argument value used.")
+            logger.warning(
+                "'comment' provided as both argument and in properties; argument value used."
+            )
         final_properties["comment"] = comment
     elif signal_type == "edit" and after is not None:
         if "after" in final_properties:
-             logger.warning("'after' provided as both argument and in properties; argument value used.")
+            logger.warning(
+                "'after' provided as both argument and in properties; argument value used."
+            )
         final_properties["after"] = after
 
     # Prepare base arguments for all signal types
@@ -292,7 +327,7 @@ def track_signal(
         "timestamp": timestamp or _get_timestamp(),
         "properties": final_properties,
         "attachment_id": attachment_id,
-        "sentiment": sentiment
+        "sentiment": sentiment,
     }
 
     try:
@@ -301,11 +336,15 @@ def track_signal(
             payload = FeedbackSignal(**base_args, signal_type=signal_type)
         elif signal_type == "edit":
             payload = EditSignal(**base_args, signal_type=signal_type)
-        else: # signal_type == "default"
+        else:  # signal_type == "default"
             if comment is not None:
-                logger.warning("'comment' argument provided for non-feedback signal type; ignored.")
+                logger.warning(
+                    "'comment' argument provided for non-feedback signal type; ignored."
+                )
             if after is not None:
-                logger.warning("'after' argument provided for non-edit signal type; ignored.")
+                logger.warning(
+                    "'after' argument provided for non-edit signal type; ignored."
+                )
             payload = DefaultSignal(**base_args, signal_type=signal_type)
 
     except ValidationError as err:
@@ -313,7 +352,7 @@ def track_signal(
         return None
 
     # model_dump handles the timestamp correctly
-    data = payload.model_dump(mode='json')
+    data = payload.model_dump(mode="json")
 
     size = _get_size(data)
     if size > max_ingest_size_bytes:
@@ -325,6 +364,7 @@ def track_signal(
 
     save_to_buffer({"type": "signals/track", "data": data})
 
+
 def begin(
     user_id: str,
     event: str,
@@ -338,10 +378,10 @@ def begin(
     Starts (or resumes) an interaction and returns a helper object.
     """
     eid = event_id or str(uuid.uuid4())
-    
-    # Prepare ai_data if input is provided
+
+    # Instantiate ai_data if either input or convo_id is supplied so that convo_id isn't lost when input is set later
     ai_data_partial = None
-    if input:
+    if input is not None or convo_id is not None:
         ai_data_partial = PartialAIData(input=input, convo_id=convo_id)
 
     # Combine properties with initial_fields, giving precedence to initial_fields if keys clash
@@ -352,17 +392,20 @@ def begin(
         user_id=user_id,
         event=event,
         ai_data=ai_data_partial,
-        properties=final_properties or None, # Pass None if empty, matching PartialTrackAIEvent defaults
+        properties=final_properties
+        or None,  # Pass None if empty, matching PartialTrackAIEvent defaults
         attachments=attachments,
     )
 
     _track_ai_partial(partial_event)
     return Interaction(eid)
 
+
 def resume_interaction(event_id: str) -> Interaction:
     """Return an Interaction wrapper for an existing eventId."""
     return Interaction(event_id)
 
+
 def _track_ai_partial(event: PartialTrackAIEvent) -> None:
     """
     Merge the incoming patch into an in-memory doc and flush to backend:
@@ -373,15 +416,22 @@ def _track_ai_partial(event: PartialTrackAIEvent) -> None:
 
     # 1. merge
     existing = _partial_buffers.get(eid, PartialTrackAIEvent(event_id=eid))
-    existing.is_pending = existing.is_pending if existing.is_pending is not None else True
+    existing.is_pending = (
+        existing.is_pending if existing.is_pending is not None else True
+    )
     merged_dict = existing.model_dump(exclude_none=True)
     incoming = event.model_dump(exclude_none=True)
 
     # deep merge ai_data / properties
     def _deep(d: dict, u: dict):
         for k, v in u.items():
-            d[k] = _deep(d.get(k, {}) if isinstance(v, dict) else v, v) if isinstance(v, dict) else v
+            d[k] = (
+                _deep(d.get(k, {}) if isinstance(v, dict) else v, v)
+                if isinstance(v, dict)
+                else v
+            )
         return d
+
     merged = _deep(merged_dict, incoming)
     merged_obj = PartialTrackAIEvent(**merged)
 
@@ -398,7 +448,10 @@ def _track_ai_partial(event: PartialTrackAIEvent) -> None:
         _partial_timers[eid].start()
 
     if debug_logs:
-        logger.debug(f"[raindrop] updated partial {eid}: {merged_obj.model_dump(exclude_none=True)}")
+        logger.debug(
+            f"[raindrop] updated partial {eid}: {merged_obj.model_dump(exclude_none=True)}"
+        )
+
 
 def _flush_partial_event(event_id: str) -> None:
     """
@@ -413,16 +466,17 @@ def _flush_partial_event(event_id: str) -> None:
 
     # convert to ordinary TrackAIEvent-ish dict before send
     data = evt.model_dump(mode="json", exclude_none=True)
-    
+
     # Apply PII redaction if enabled
     if redact_pii:
         data = perform_pii_redaction(data)
-    
+
     size = _get_size(data)
     if size > max_ingest_size_bytes:
         logger.warning(f"[raindrop] partial event {event_id} > 1 MB; skipping")
         return
-    
+
     send_request("events/track_partial", data)
 
-atexit.register(shutdown)
+
+atexit.register(shutdown)

raindrop_ai-0.0.27/raindrop/version.py

@@ -0,0 +1 @@
+VERSION = "0.0.27"

raindrop_ai-0.0.26/raindrop/version.py

@@ -1 +0,0 @@
-VERSION = "0.0.26"