raindrop-ai 0.0.19__tar.gz

raindrop_ai-0.0.19/PKG-INFO

@@ -0,0 +1,28 @@
+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

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

raindrop_ai-0.0.19/raindrop/analytics.py

@@ -0,0 +1,283 @@
+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/version.py

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

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1 @@
+

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

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

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

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

raindrop_ai-0.0.19/setup.cfg

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

raindrop_ai-0.0.19/setup.py

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,254 @@
+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()