raindrop-ai 0.0.19__tar.gz → 0.0.21__tar.gz

raindrop_ai-0.0.21/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: raindrop-ai
+Version: 0.0.21
+Summary: Raindrop AI (Python SDK)
+License: MIT
+Author: Raindrop AI
+Author-email: sdk@raindrop.ai
+Requires-Python: >=3.11, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*, !=3.8.*, !=3.9.*, !=3.10.*
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pydantic (>=2.11,<3)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Raindrop Python SDK
+
+## Installation dependencies
+
+
+```bash
+pip install poetry
+```
+
+```bash
+poetry install
+```
+
+
+## Run tests
+
+```bash
+poetry run green -vv
+```
+
+
+
+
+
+

raindrop_ai-0.0.21/README.md

@@ -0,0 +1,24 @@
+# Raindrop Python SDK
+
+## Installation dependencies
+
+
+```bash
+pip install poetry
+```
+
+```bash
+poetry install
+```
+
+
+## Run tests
+
+```bash
+poetry run green -vv
+```
+
+
+
+
+

raindrop_ai-0.0.21/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "raindrop-ai"
+version = "0.0.21"
+description = "Raindrop AI (Python SDK)"
+authors = ["Raindrop AI <sdk@raindrop.ai>"]
+license = "MIT"
+readme = "README.md"
+packages = [{include = "raindrop"}]
+
+[tool.poetry.dependencies]
+python = ">=3.11,<3.12.1 || >3.12.1,<4.0"
+pydantic = ">=2.11,<3"
+requests = "^2.32.3"
+
+
+[tool.poetry.group.dev.dependencies]
+green = "^4.0.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

raindrop_ai-0.0.21/raindrop/analytics.py

@@ -0,0 +1,405 @@
+import sys
+import time
+import threading
+from typing import Union, List, Dict, Optional, Literal, Any
+import requests
+from datetime import datetime, timezone
+import logging
+import json
+import uuid
+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.interaction import Interaction
+
+
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+write_key = None
+api_url = "https://api.raindrop.ai/v1/"
+max_queue_size = 10000
+upload_size = 10
+upload_interval = 1.0
+buffer = []
+flush_lock = threading.Lock()
+debug_logs = False
+flush_thread = None
+shutdown_event = threading.Event()
+max_ingest_size_bytes = 1 * 1024 * 1024  # 1 MB
+
+_partial_buffers: dict[str, PartialTrackAIEvent] = {}
+_partial_timers: dict[str, Timer] = {}
+_PARTIAL_TIMEOUT = 2  # 2 seconds 
+
+def set_debug_logs(value: bool):
+    global debug_logs
+    debug_logs = value
+    if debug_logs:
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.INFO)
+
+def start_flush_thread():
+    logger.debug("Opening flush thread")
+    global flush_thread
+    if flush_thread is None:
+        flush_thread = threading.Thread(target=flush_loop)
+        flush_thread.daemon = True
+        flush_thread.start()
+
+def flush_loop():
+    while not shutdown_event.is_set():
+        try:
+            flush()
+        except Exception as e:
+            logger.error(f"Error in flush loop: {e}")
+        time.sleep(upload_interval)
+
+def flush() -> None:
+    global buffer
+
+    if buffer is None:
+        logger.error("No buffer available")
+        return
+
+    logger.debug("Starting flush")
+
+    with flush_lock:
+        current_buffer = buffer
+        buffer = []
+
+    logger.debug(f"Flushing buffer size: {len(current_buffer)}")
+
+    grouped_events = {}
+    for event in current_buffer:
+        endpoint = event["type"]
+        data = event["data"]
+        if endpoint not in grouped_events:
+            grouped_events[endpoint] = []
+        grouped_events[endpoint].append(data)
+
+    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]
+            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:
+    
+    url = f"{api_url}{endpoint}"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {write_key}",
+    }
+
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(url, json=data_entries, headers=headers)
+            response.raise_for_status()
+            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}")
+            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")
+
+    if len(buffer) >= max_queue_size:
+        logger.error("Buffer is full. Discarding event.")
+        return
+
+    logger.debug(f"Adding event to buffer: {event}")
+
+    with flush_lock:
+        buffer.append(event)
+
+    start_flush_thread()
+
+def identify(user_id: str, traits: Dict[str, Union[str, int, bool, float]]) -> None:
+    if not _check_write_key():
+        return
+    data = {"user_id": user_id, "traits": traits}
+    save_to_buffer({"type": "users/identify", "data": data})
+
+
+def track_ai(
+    user_id: str,
+    event: str,
+    event_id: Optional[str] = None,
+    model: Optional[str] = None,
+    input: Optional[str] = None,
+    output: Optional[str] = None,
+    convo_id: Optional[str] = None,
+    properties: Optional[Dict[str, Union[str, int, bool, float]]] = None,
+    timestamp: Optional[str] = None,
+    attachments: Optional[List[Attachment]] = None,
+) -> str:
+    if not _check_write_key():
+        return
+    
+    event_id = event_id or str(uuid.uuid4())
+
+    try:
+        payload = TrackAIEvent(
+            event_id=event_id,
+            user_id=user_id,
+            event=event,
+            timestamp=timestamp or _get_timestamp(),
+            properties=properties or {},
+            ai_data=dict(          # Pydantic will coerce to AIData
+                model=model,
+                input=input,
+                output=output,
+                convo_id=convo_id,
+            ),
+            attachments=attachments,
+        )
+    except ValidationError as err:
+        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()
+
+    size = _get_size(data)
+    if size > max_ingest_size_bytes:
+        logger.warning(
+            f"[raindrop] Events larger than {max_ingest_size_bytes / (1024 * 1024)} MB may have properties truncated - "
+            f"an event of size {size / (1024 * 1024):.2f} MB was logged"
+        )
+        return None  # Skip adding oversized events to buffer
+
+    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) 
+
+    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.")
+        return False
+    return True
+
+def _get_context():
+    return {
+        "library": {
+            "name": "python-sdk",
+            "version": VERSION,
+        },
+        "metadata": {
+            "pyVersion": f"v{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+        },
+    }
+
+def _get_timestamp():
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+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'))
+    except (TypeError, OverflowError) as e:
+        logger.error(f"Error serializing event for size calculation: {e}")
+        return 0 
+
+# Signal types - This is now defined in models.py
+# SignalType = Literal["default", "feedback", "edit"]
+
+def track_signal(
+    event_id: str,
+    name: str,
+    signal_type: Literal["default", "feedback", "edit"] = "default",
+    timestamp: Optional[str] = None,
+    properties: Optional[Dict[str, Any]] = None,
+    attachment_id: Optional[str] = None,
+    comment: Optional[str] = None,
+    after: Optional[str] = None
+) -> None:
+    """
+    Track a signal event.
+
+    Args:
+        event_id: The ID of the event to attach the signal to
+        name: Name of the signal (e.g. "thumbs_up", "thumbs_down")
+        signal_type: Type of signal ("default", "feedback", or "edit")
+        timestamp: Optional timestamp for the signal (ISO 8601 format)
+        properties: Optional dictionary of additional properties.
+        attachment_id: Optional ID of an attachment
+        comment: Optional comment string (required and used only if signal_type is 'feedback').
+        after: Optional after content string (required and used only if signal_type is 'edit').
+    """
+    if not _check_write_key():
+        return
+
+    # Prepare the final properties dictionary
+    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.")
+        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.")
+        final_properties["after"] = after
+
+    # Prepare base arguments for all signal types
+    base_args = {
+        "event_id": event_id,
+        "signal_name": name,
+        "timestamp": timestamp or _get_timestamp(),
+        "properties": final_properties,
+        "attachment_id": attachment_id,
+    }
+
+    try:
+        # Construct the specific signal model based on signal_type
+        if signal_type == "feedback":
+            payload = FeedbackSignal(**base_args, signal_type=signal_type)
+        elif signal_type == "edit":
+            payload = EditSignal(**base_args, signal_type=signal_type)
+        else: # signal_type == "default"
+            if comment is not None:
+                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.")
+            payload = DefaultSignal(**base_args, signal_type=signal_type)
+
+    except ValidationError as err:
+        logger.error(f"[raindrop] Invalid data passed to track_signal: {err}")
+        return None
+
+    # model_dump handles the timestamp correctly
+    data = payload.model_dump(mode='json')
+
+    size = _get_size(data)
+    if size > max_ingest_size_bytes:
+        logger.warning(
+            f"[raindrop] Events larger than {max_ingest_size_bytes / (1024 * 1024)} MB may have properties truncated - "
+            f"an event of size {size / (1024 * 1024):.2f} MB was logged"
+        )
+        return  # Skip adding oversized events to buffer
+
+    save_to_buffer({"type": "signals/track", "data": data})
+
+def begin(
+    user_id: str,
+    event: str,
+    event_id: str | None = None,
+    properties: Optional[Dict[str, Any]] = None,
+    input: Optional[str] = None,
+    attachments: Optional[List[Attachment]] = None,
+) -> Interaction:
+    """
+    Starts (or resumes) an interaction and returns a helper object.
+    """
+    eid = event_id or str(uuid.uuid4())
+    
+    # Prepare ai_data if input is provided
+    ai_data_partial = None
+    if input:
+        ai_data_partial = PartialAIData(input=input)
+
+    # Combine properties with initial_fields, giving precedence to initial_fields if keys clash
+    final_properties = (properties or {}).copy()
+
+    partial_event = PartialTrackAIEvent(
+        event_id=eid,
+        user_id=user_id,
+        event=event,
+        ai_data=ai_data_partial,
+        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:
+      • on `.finish()`  (is_pending == False)
+      • or after 20 s of inactivity
+    """
+    eid = event.event_id
+
+    # 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
+    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
+        return d
+    merged = _deep(merged_dict, incoming)
+    merged_obj = PartialTrackAIEvent(**merged)
+
+    _partial_buffers[eid] = merged_obj
+
+    # 2. timer handling
+    if t := _partial_timers.get(eid):
+        t.cancel()
+    if merged_obj.is_pending is False:
+        _flush_partial_event(eid)
+    else:
+        _partial_timers[eid] = Timer(_PARTIAL_TIMEOUT, _flush_partial_event, args=[eid])
+        _partial_timers[eid].daemon = True
+        _partial_timers[eid].start()
+
+    if debug_logs:
+        logger.debug(f"[raindrop] updated partial {eid}: {merged_obj.model_dump(exclude_none=True)}")
+
+def _flush_partial_event(event_id: str) -> None:
+    """
+    Send the accumulated patch as a single object to `events/track_partial`.
+    """
+    if t := _partial_timers.pop(event_id, None):
+        t.cancel()
+
+    evt = _partial_buffers.pop(event_id, None)
+    if not evt:
+        return
+
+    # convert to ordinary TrackAIEvent-ish dict before send
+    data = evt.model_dump(mode="json", exclude_none=True)
+    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)

raindrop_ai-0.0.21/raindrop/interaction.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+from typing import Any, Dict, List, Optional, Callable
+from uuid import uuid4
+
+from .models import Attachment, PartialTrackAIEvent
+from . import analytics as _core
+
+
+class Interaction:
+    """
+    Thin helper returned by analytics.begin().
+    Each mutator just relays a partial update back to Analytics.
+    """
+    __slots__ = ("_event_id", "_analytics")
+
+    def __init__(self, event_id: Optional[str] = None):
+        self._event_id = event_id or str(uuid4())
+        self._analytics = _core
+        
+
+    # -- mutators ----------------------------------------------------------- #
+    def set_input(self, text: str) -> None:
+        self._analytics._track_ai_partial(
+            PartialTrackAIEvent(event_id=self._event_id, ai_data={"input": text})
+        )
+
+    def add_attachments(self, attachments: List[Attachment]) -> None:
+        self._analytics._track_ai_partial(
+            PartialTrackAIEvent(event_id=self._event_id, attachments=attachments)
+        )
+
+    def set_properties(self, props: Dict[str, Any]) -> None:
+        self._analytics._track_ai_partial(
+            PartialTrackAIEvent(event_id=self._event_id, properties=props)
+        )
+
+    def finish(self, *, output: str | None = None, **extra) -> None:
+        payload = PartialTrackAIEvent(
+            event_id=self._event_id,
+            ai_data={"output": output} if output is not None else None,
+            is_pending=False,
+            **extra,
+        )
+        self._analytics._track_ai_partial(payload)
+
+    # convenience
+    @property
+    def id(self) -> str:
+        return self._event_id

raindrop_ai-0.0.21/raindrop/models.py

@@ -0,0 +1,133 @@
+from pydantic import BaseModel, Field, ValidationError, model_validator, field_validator
+from typing import Any, Optional, Dict, Literal, List, Union
+from datetime import datetime, timezone
+
+class _Base(BaseModel):
+    model_config = dict(extra="forbid", validate_default=True)
+
+
+class Attachment(BaseModel):
+    type: Literal["code", "text", "image", "iframe"]
+    value: str                       # URL, raw code, etc.
+    name: Optional[str] = None       # e.g. "Generated SQL"
+    role: Optional[Literal["input", "output", "context"]] = None
+    language: Optional[str] = None   # for code snippets
+
+    @model_validator(mode="after")
+    def _require_value(cls, values):
+        if not values.value:
+            raise ValueError("value must be non-empty.")
+        return values
+
+class AIData(_Base):
+    model: Optional[str]
+    input: Optional[str]
+    output: Optional[str]
+    convo_id: Optional[str]
+
+    @model_validator(mode="after")
+    def _require_input_or_output(cls, values):
+        if not (values.input or values.output):
+            raise ValueError("Either 'input' or 'output' must be non-empty.")
+        return values
+    
+class TrackAIEvent(_Base):
+    event_id: Optional[str] = None
+    user_id: str
+    event: str
+    ai_data: AIData
+    properties: Dict[str, Any] = Field(default_factory=dict)
+    timestamp: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+    )
+    attachments: Optional[List[Attachment]] = None
+
+    # Ensure user_id and event are non-empty strings
+    @field_validator("user_id", "event")
+    def _non_empty(cls, v, info):
+        if v is None or (isinstance(v, str) and v.strip() == ""):
+            raise ValueError(f"'{info.field_name}' must be a non-empty string.")
+        return v
+
+    # No need to duplicate input/output check here; AIData already enforces it
+    # but keep method to return values unchanged so that pydantic doesn't complain about unused return
+
+
+# --- Signal Tracking Models --- #
+
+class BaseSignal(_Base):
+    """Base model for signal events, containing common fields."""
+    event_id: str
+    signal_name: str
+    timestamp: datetime = Field(
+        # Return a datetime object; Pydantic's model_dump will handle serialization to string
+        default_factory=lambda: datetime.now(timezone.utc).replace(microsecond=0)
+    )
+    properties: Dict[str, Any] = Field(default_factory=dict)
+    attachment_id: Optional[str] = None
+
+    @field_validator("event_id", "signal_name")
+    def _non_empty_strings(cls, v, info):
+        if not isinstance(v, str) or not v.strip():
+            raise ValueError(f"'{info.field_name}' must be a non-empty string.")
+        return v
+
+class DefaultSignal(BaseSignal):
+    """Model for default signal events."""
+    signal_type: Literal["default"] = "default"
+
+class FeedbackSignal(BaseSignal):
+    """Model for feedback signal events, requiring a comment."""
+    signal_type: Literal["feedback"]
+
+    @model_validator(mode="after")
+    def _check_comment_in_properties(cls, values):
+        # Check properties safely after potential initialization
+        # Use getattr to safely access properties, returning None if not present
+        props = getattr(values, 'properties', None) 
+        if not isinstance(props, dict):
+             raise ValueError("'properties' must be a dictionary for feedback signals.")
+        comment = props.get("comment")
+        if not comment or not isinstance(comment, str) or not comment.strip():
+            raise ValueError("'properties' must contain a non-empty string 'comment' for feedback signals.")
+        return values
+
+class EditSignal(BaseSignal):
+    """Model for edit signal events, requiring after content."""
+    signal_type: Literal["edit"]
+
+    @model_validator(mode="after")
+    def _check_after_in_properties(cls, values):
+        # Check properties safely after potential initialization
+        props = getattr(values, 'properties', None)
+        if not isinstance(props, dict):
+             raise ValueError("'properties' must be a dictionary for edit signals.")
+        after = props.get("after")
+        if not after or not isinstance(after, str) or not after.strip():
+             raise ValueError("'properties' must contain a non-empty string 'after' for edit signals.")
+        return values
+
+# Discriminated Union for Signal Events
+# Pydantic will automatically use the 'signal_type' field to determine which model to use.
+SignalEvent = Union[DefaultSignal, FeedbackSignal, EditSignal]
+
+# --- End Signal Tracking Models --- #
+
+
+class PartialAIData(_Base):
+    """Looser version for incremental updates."""
+    model: Optional[str] = None
+    input: Optional[str] = None
+    output: Optional[str] = None
+    convo_id: Optional[str] = None 
+
+class PartialTrackAIEvent(_Base):
+    """Accepts *any subset* of TrackAIEvent fields."""
+    event_id: str                                 # always required for merge-key
+    user_id: Optional[str] = None
+    event: Optional[str] = None
+    ai_data: Optional[PartialAIData] = None
+    timestamp: Optional[datetime] = None
+    properties: Optional[Dict[str, Any]] = None
+    attachments: Optional[List[Attachment]] = None
+    is_pending: Optional[bool] = True

raindrop_ai-0.0.19/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.4
-Name: raindrop-ai
-Version: 0.0.19
-Summary: Raindrop AI (Python SDK)
-Home-page: https://raindrop.ai
-Author: Raindrop AI
-Author-email: sdk@raindrop.ai
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Description-Content-Type: text/markdown
-Requires-Dist: requests
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: summary
-
-For questions, email us at sdk@raindrop.ai

raindrop_ai-0.0.19/README.md

@@ -1,3 +0,0 @@
-# Python SDK for dawnai.com
-
-to run tests: python3 -m unittest discover tests

raindrop_ai-0.0.19/raindrop/analytics.py

@@ -1,283 +0,0 @@
-import sys
-import time
-import threading
-from typing import Union, List, Dict, Optional, Literal
-import requests
-from datetime import datetime, timezone
-import logging
-import json
-import uuid
-import atexit
-from raindrop.version import VERSION
-
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-write_key = None
-api_url = "https://api.raindrop.ai/v1/"
-max_queue_size = 10000
-upload_size = 10
-upload_interval = 1.0
-buffer = []
-flush_lock = threading.Lock()
-debug_logs = False
-flush_thread = None
-shutdown_event = threading.Event()
-max_ingest_size_bytes = 1 * 1024 * 1024  # 1 MB
-
-def set_debug_logs(value: bool):
-    global debug_logs
-    debug_logs = value
-    if debug_logs:
-        logger.setLevel(logging.DEBUG)
-    else:
-        logger.setLevel(logging.INFO)
-
-def start_flush_thread():
-    logger.debug("Opening flush thread")
-    global flush_thread
-    if flush_thread is None:
-        flush_thread = threading.Thread(target=flush_loop)
-        flush_thread.daemon = True
-        flush_thread.start()
-
-def flush_loop():
-    while not shutdown_event.is_set():
-        try:
-            flush()
-        except Exception as e:
-            logger.error(f"Error in flush loop: {e}")
-        time.sleep(upload_interval)
-
-def flush() -> None:
-    global buffer
-
-    if buffer is None:
-        logger.error("No buffer available")
-        return
-
-    logger.debug("Starting flush")
-
-    with flush_lock:
-        current_buffer = buffer
-        buffer = []
-
-    logger.debug(f"Flushing buffer size: {len(current_buffer)}")
-
-    grouped_events = {}
-    for event in current_buffer:
-        endpoint = event["type"]
-        data = event["data"]
-        if endpoint not in grouped_events:
-            grouped_events[endpoint] = []
-        grouped_events[endpoint].append(data)
-
-    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]
-            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:
-    
-    url = f"{api_url}{endpoint}"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {write_key}",
-    }
-
-    max_retries = 3
-    for attempt in range(max_retries):
-        try:
-            response = requests.post(url, json=data_entries, headers=headers)
-            response.raise_for_status()
-            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}")
-            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")
-
-    if len(buffer) >= max_queue_size:
-        logger.error("Buffer is full. Discarding event.")
-        return
-
-    logger.debug(f"Adding event to buffer: {event}")
-
-    with flush_lock:
-        buffer.append(event)
-
-    start_flush_thread()
-
-def identify(user_id: str, traits: Dict[str, Union[str, int, bool, float]]) -> None:
-    if not _check_write_key():
-        return
-    data = {"user_id": user_id, "traits": traits}
-    save_to_buffer({"type": "users/identify", "data": data})
-
-def track(
-    user_id: str,
-    event: str,
-    properties: Optional[Dict[str, Union[str, int, bool, float]]] = None,
-    timestamp: Optional[str] = None,
-) -> None:
-    if not _check_write_key():
-        return
-
-    data = {
-        "event_id": str(uuid.uuid4()),
-        "user_id": user_id,
-        "event": event,
-        "properties": properties,
-        "timestamp": timestamp if timestamp else _get_timestamp(),
-    }
-    data.setdefault("properties", {})["$context"] = _get_context()
-
-    save_to_buffer({"type": "events/track", "data": data})
-
-def track_ai(
-    user_id: str,
-    event: str,
-    model: Optional[str] = None,
-    user_input: Optional[str] = None,
-    output: Optional[str] = None,
-    convo_id: Optional[str] = None,
-    properties: Optional[Dict[str, Union[str, int, bool, float]]] = None,
-    timestamp: Optional[str] = None,
-) -> None:
-    if not _check_write_key():
-        return
-
-    if not user_input and not output:
-        raise ValueError("One of user_input or output must be provided and not empty.")
-
-    event_id = str(uuid.uuid4())
-
-    data = {
-        "event_id": event_id,
-        "user_id": user_id,
-        "event": event,
-        "properties": properties or {},
-        "timestamp": timestamp if timestamp else _get_timestamp(),
-        "ai_data": {
-            "model": model,
-            "input": user_input,
-            "output": output,
-            "convo_id": convo_id,
-        },
-    }
-    data.setdefault("properties", {})["$context"] = _get_context()
-
-    size = _get_size(data)
-    if size > max_ingest_size_bytes:
-        logger.warning(
-            f"[raindrop] Events larger than {max_ingest_size_bytes / (1024 * 1024)} MB may have properties truncated - "
-            f"an event of size {size / (1024 * 1024):.2f} MB was logged"
-        )
-        return None  # Skip adding oversized events to buffer
-
-    save_to_buffer({"type": "events/track", "data": data})
-    return event_id
-
-def shutdown():
-    logger.info("Shutting down raindrop analytics")
-    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.")
-        return False
-    return True
-
-def _get_context():
-    return {
-        "library": {
-            "name": "python-sdk",
-            "version": VERSION,
-        },
-        "metadata": {
-            "pyVersion": f"v{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-        },
-    }
-
-def _get_timestamp():
-    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
-
-
-def _get_size(event: dict[str, any]) -> int:
-    try:
-        data = json.dumps(event)
-        return len(data.encode('utf-8'))
-    except (TypeError, OverflowError) as e:
-        logger.error(f"Error serializing event for size calculation: {e}")
-        return 0 
-
-# Signal types
-SignalType = Literal["default", "feedback", "edit"]
-
-def track_signal(
-    event_id: str,
-    name: str,
-    signal_type: Optional[SignalType] = "default",
-    timestamp: Optional[str] = None,
-    properties: Optional[Dict[str, any]] = None,
-    attachment_id: Optional[str] = None,
-    comment: Optional[str] = None,
-    after: Optional[str] = None,
-) -> None:
-    """
-    Track a signal event.
-
-    Args:
-        event_id: The ID of the event to attach the signal to
-        name: Name of the signal (e.g. "thumbs_up", "thumbs_down")
-        signal_type: Type of signal ("default", "feedback", or "edit")
-        timestamp: Optional timestamp for the signal
-        properties: Optional properties for the signal
-        attachment_id: Optional ID of an attachment
-        comment: Optional comment (only for feedback signals)
-        after: Optional after content (only for edit signals)
-    """
-    if not _check_write_key():
-        return
-
-    # Prepare properties with optional comment and after fields
-    signal_properties = properties or {}
-    if comment is not None:
-        signal_properties["comment"] = comment
-    if after is not None:
-        signal_properties["after"] = after
-
-    data = {
-        "event_id": event_id,
-        "signal_name": name,
-        "signal_type": signal_type,
-        "timestamp": timestamp if timestamp else _get_timestamp(),
-        "properties": signal_properties,
-        "attachment_id": attachment_id,
-    }
-
-    size = _get_size(data)
-    if size > max_ingest_size_bytes:
-        logger.warning(
-            f"[raindrop] Events larger than {max_ingest_size_bytes / (1024 * 1024)} MB may have properties truncated - "
-            f"an event of size {size / (1024 * 1024):.2f} MB was logged"
-        )
-        return  # Skip adding oversized events to buffer
-
-    save_to_buffer({"type": "signals/track", "data": data})
-
-atexit.register(shutdown)

raindrop_ai-0.0.19/raindrop_ai.egg-info/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.4
-Name: raindrop-ai
-Version: 0.0.19
-Summary: Raindrop AI (Python SDK)
-Home-page: https://raindrop.ai
-Author: Raindrop AI
-Author-email: sdk@raindrop.ai
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Description-Content-Type: text/markdown
-Requires-Dist: requests
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: summary
-
-For questions, email us at sdk@raindrop.ai

raindrop_ai-0.0.19/raindrop_ai.egg-info/SOURCES.txt

@@ -1,11 +0,0 @@
-README.md
-setup.py
-raindrop/__init__.py
-raindrop/analytics.py
-raindrop/version.py
-raindrop_ai.egg-info/PKG-INFO
-raindrop_ai.egg-info/SOURCES.txt
-raindrop_ai.egg-info/dependency_links.txt
-raindrop_ai.egg-info/requires.txt
-raindrop_ai.egg-info/top_level.txt
-tests/test_analytics.py

raindrop_ai-0.0.19/raindrop_ai.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

raindrop_ai-0.0.19/raindrop_ai.egg-info/requires.txt

@@ -1 +0,0 @@
-requests

raindrop_ai-0.0.19/raindrop_ai.egg-info/top_level.txt

@@ -1 +0,0 @@
-raindrop

raindrop_ai-0.0.19/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

raindrop_ai-0.0.19/setup.py

@@ -1,34 +0,0 @@
-import sys
-import os
-
-from setuptools import setup, find_packages
-
-# Don't import raindrop-ai module here, since deps may not be installed
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'raindrop'))
-from version import VERSION
-
-setup(
-    name="raindrop-ai",
-    version=VERSION,
-    description="Raindrop AI (Python SDK)",
-    author="Raindrop AI",
-    author_email="sdk@raindrop.ai",
-    long_description="For questions, email us at sdk@raindrop.ai",
-    long_description_content_type="text/markdown",
-    url="https://raindrop.ai",
-    packages=find_packages(include=["raindrop", "README.md"]),
-    install_requires=[
-        "requests",
-    ],
-    classifiers=[
-        "Development Status :: 3 - Alpha",
-        "Intended Audience :: Developers",
-        "Programming Language :: Python",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-    ],
-)

raindrop_ai-0.0.19/tests/test_analytics.py

@@ -1,254 +0,0 @@
-import time
-import unittest
-from unittest.mock import patch
-import raindrop.analytics as analytics
-from raindrop.version import VERSION
-import sys
-
-
-class TestAnalytics(unittest.TestCase):
-    def setUp(self):
-        # Set up any necessary test data or configurations
-        analytics.write_key = "0000"
-        analytics.api_url = "http://localhost:3000/"
-
-    def tearDown(self):
-        # Clean up any resources or reset any state after each test
-        analytics.flush()
-        pass
-
-    def test_identify(self):
-        with patch('requests.post') as mock_post:
-            user_id = "user123"
-            traits = {"email": "john@example.com", "name": "John"}
-
-            analytics.identify(user_id, traits)
-            analytics.flush()  # Force flush to trigger request
-
-            # Verify the POST request was made
-            mock_post.assert_called_once()
-            
-            # Get the data that was sent
-            call_args = mock_post.call_args
-            url = call_args[0][0]
-            data = call_args[1]['json'][0]  # First event in the batch
-            
-            # Verify URL and data
-            self.assertEqual(url, "http://localhost:3000/users/identify")
-            self.assertEqual(data['user_id'], user_id)
-            self.assertEqual(data['traits'], traits)
-
-    @patch('requests.post')
-    def test_track(self, mock_post):
-        # Test data
-        user_id = "user123"
-        event = "signed_up"
-        properties = {"plan": "Premium"}
-        
-        # Track the event
-        analytics.track(user_id, event, properties)
-        
-        # Force a flush to trigger the HTTP request
-        analytics.flush()
-        
-        # Verify the POST request was made
-        mock_post.assert_called_once()
-        
-        # Get the data that was sent
-        call_args = mock_post.call_args
-        url = call_args[0][0]
-        data = call_args[1]['json'][0]  # First event in the batch
-        
-        # Verify URL
-        self.assertEqual(url, "http://localhost:3000/events/track")
-        
-        # Verify request structure
-        self.assertEqual(data['user_id'], user_id)
-        self.assertEqual(data['event'], event)
-        self.assertEqual(data['properties']['plan'], "Premium")
-        
-        # Verify context data
-        self.assertEqual(data['properties']['$context']['library']['name'], "python-sdk")
-        self.assertEqual(data['properties']['$context']['library']['version'], VERSION)
-        self.assertEqual(
-            data['properties']['$context']['metadata']['pyVersion'],
-            f"v{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
-        )
-        
-        # Verify other required fields
-        self.assertIn('event_id', data)
-        self.assertIn('timestamp', data)
-
-    @patch('requests.post')
-    def test_track_ai(self, mock_post):
-        # Test data
-        user_id = "user123"
-        event = "ai_completion"
-        model = "gpt-3.5"
-        user_input = "Hello"
-        output = "Hi there!"
-        convo_id = "conv123"
-        properties = {"temperature": 0.7}
-        
-        # Track the AI event
-        analytics.track_ai(
-            user_id=user_id,
-            event=event,
-            model=model,
-            user_input=user_input,
-            output=output,
-            convo_id=convo_id,
-            properties=properties
-        )
-        
-        # Force a flush
-        analytics.flush()
-        
-        # Verify the POST request was made
-        mock_post.assert_called_once()
-        
-        # Get the data that was sent
-        call_args = mock_post.call_args
-        data = call_args[1]['json'][0]  # First event in the batch
-        
-        # Verify AI-specific fields
-        self.assertEqual(data['ai_data']['model'], model)
-        self.assertEqual(data['ai_data']['input'], user_input)
-        self.assertEqual(data['ai_data']['output'], output)
-        self.assertEqual(data['ai_data']['convo_id'], convo_id)
-        
-        # Verify common fields
-        self.assertEqual(data['user_id'], user_id)
-        self.assertEqual(data['event'], event)
-        self.assertEqual(data['properties']['temperature'], 0.7)
-        self.assertIn('event_id', data)
-        self.assertIn('timestamp', data)
-
-    def test_flush(self):
-        with patch('requests.post') as mock_post:
-            user_id = "user123"
-            event = "ai_chat"
-            model = "GPT-3"
-            input_text = "Hello"
-            output_text = "Hi there!"
-
-            analytics.track_ai(
-                user_id, event, model=model, user_input=input_text, output=output_text
-            )
-
-            analytics.flush()  # Force flush
-
-            # Verify the buffer is empty after flush
-            self.assertEqual(len(analytics.buffer), 0)
-            
-            # Verify the POST request was made
-            mock_post.assert_called_once()
-
-    def test_track_ai_with_size_limit(self):
-        with patch('requests.post') as mock_post:
-            user_id = "user123"
-            event = "ai_chat_test"
-            model = "GPT-3"
-            input_text = "Hello"
-            output_text = "Hi there!"
-            properties = {
-                "key": "v" * 10000,
-                "key2": "v" * 10000,
-                "key3": "v" * 1048576,  # 1 MB of data (1024 * 1024 bytes)
-            }
-
-            # Capture logged output
-            with self.assertLogs('dawnai.analytics', level='WARNING') as log_capture:
-                analytics.track_ai(
-                    user_id, event, model=model, user_input=input_text, output=output_text, properties=properties
-                )
-                analytics.flush()  # Force flush
-
-            # Check the logged output
-            self.assertTrue(any("[dawn] Events larger than" in message for message in log_capture.output),
-                            "Expected size warning is not logged")
-
-            # Verify no request was made since event was too large
-            mock_post.assert_not_called()
-
-    @patch('requests.post')
-    def test_track_signal(self, mock_post):
-        # Test basic signal tracking
-        event_id = "event123"
-        name = "thumbs_up"
-        signal_type = "feedback"
-        properties = {"rating": 5}
-        comment = "Great response!"
-        attachment_id = "attach123"
-        after = "Updated content"
-
-        # Track signal with all fields
-        analytics.track_signal(
-            event_id=event_id,
-            name=name,
-            signal_type=signal_type,
-            properties=properties,
-            comment=comment,
-            attachment_id=attachment_id,
-            after=after
-        )
-        
-        # Force a flush
-        analytics.flush()
-        
-        # Verify the POST request was made
-        mock_post.assert_called_once()
-        
-        # Get the data that was sent
-        call_args = mock_post.call_args
-        url = call_args[0][0]
-        data = call_args[1]['json'][0]  # First event in the batch
-        
-        # Verify URL
-        self.assertEqual(url, "http://localhost:3000/signals/track")
-        
-        # Verify signal data
-        self.assertEqual(data['event_id'], event_id)
-        self.assertEqual(data['signal_name'], name)
-        self.assertEqual(data['signal_type'], signal_type)
-        self.assertEqual(data['attachment_id'], attachment_id)
-        
-        # Verify properties including comment and after
-        self.assertEqual(data['properties']['rating'], 5)
-        self.assertEqual(data['properties']['comment'], comment)
-        self.assertEqual(data['properties']['after'], after)
-
-        # Test size limit handling
-        mock_post.reset_mock()
-        large_properties = {
-            "key": "v" * 10000,
-            "key2": "v" * 10000,
-            "key3": "v" * 1048576,  # 1 MB of data
-        }
-
-        # Capture logged output for oversized event
-        with self.assertLogs('dawnai.analytics', level='WARNING') as log_capture:
-            analytics.track_signal(
-                event_id=event_id,
-                name=name,
-                properties=large_properties
-            )
-            analytics.flush()
-
-        # Check the logged output
-        self.assertTrue(any("[dawn] Events larger than" in message for message in log_capture.output),
-                       "Expected size warning is not logged")
-
-        # Test different signal types
-        mock_post.reset_mock()
-        for signal_type in ["default", "feedback", "edit"]:
-            analytics.track_signal(
-                event_id=event_id,
-                name=name,
-                signal_type=signal_type
-            )
-            analytics.flush()
-            
-            data = mock_post.call_args[1]['json'][0]
-            self.assertEqual(data['signal_type'], signal_type)
-            mock_post.reset_mock()