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

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

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

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

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

{raindrop_ai-0.0.25 → raindrop_ai-0.0.26}/raindrop/redact.py

@@ -8,6 +8,10 @@ class PIIRedactor:
     """PII redactor that uses regex patterns to identify and replace PII."""
     
     def __init__(self):
+        # Load well-known names
+        well_known_names_path = os.path.join(os.path.dirname(__file__), 'well-known-names.json')
+        with open(well_known_names_path, 'r') as f:
+            self.well_known_names = json.load(f)
         
         # Build regex patterns
         self._build_patterns()
@@ -64,6 +68,9 @@ class PIIRedactor:
             re.MULTILINE
         )
         
+        # Well-known names pattern
+        names_pattern_str = r'\b(' + '|'.join(re.escape(name) for name in self.well_known_names) + r')\b'
+        self.well_known_names_pattern = re.compile(names_pattern_str, re.IGNORECASE)
         
         # Credentials pattern (API keys, tokens, etc.)
         self.credentials_pattern = re.compile(
@@ -71,6 +78,61 @@ class PIIRedactor:
             re.IGNORECASE
         )
 
+    
+    def redact_names(self, text: str) -> str:
+        """Redact names using greeting/closing context and well-known names."""
+        if not isinstance(text, str):
+            return text
+        
+        # First, redact well-known names
+        text = self.well_known_names_pattern.sub('<REDACTED_NAME>', text)
+        
+        # Find names after greetings
+        greeting_matches = list(self.greeting_pattern.finditer(text))
+        for match in reversed(greeting_matches):  # Process in reverse to maintain positions
+            # Look for capitalized words after the greeting
+            start_pos = match.end()
+            # Find the next word(s) that could be a name
+            name_match = re.match(r'\s*([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)', text[start_pos:])
+            if name_match:
+                # Replace the name
+                name_start = start_pos + name_match.start(1)
+                name_end = start_pos + name_match.end(1)
+                text = text[:name_start] + '<REDACTED_NAME>' + text[name_end:]
+        
+        # Find names before closings
+        lines = text.split('\n')
+        for i, line in enumerate(lines):
+            closing_match = self.closing_pattern.search(line)
+            if closing_match:
+                # Look for names before the closing
+                before_closing = line[:closing_match.start()]
+                # Check if there's a name at the end of the text before closing
+                name_before_closing = re.search(r'([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\s*$', before_closing)
+                if name_before_closing:
+                    lines[i] = (before_closing[:name_before_closing.start(1)] + 
+                               '<REDACTED_NAME>' + 
+                               before_closing[name_before_closing.end(1):] + 
+                               line[closing_match.start():])
+        
+        text = '\n'.join(lines)
+        
+        # Use generic name pattern for standalone names (like signatures)
+        # Only apply to lines that look like signatures (short lines with just names)
+        lines = text.split('\n')
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            # Check if line looks like a signature (short, starts with capital, no other context)
+            if (len(stripped) < 50 and 
+                re.match(r'^[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*[,.]?$', stripped) and
+                '<REDACTED_NAME>' not in line):
+                lines[i] = line.replace(stripped, '<REDACTED_NAME>')
+        
+        text = '\n'.join(lines)
+        
+        return text
+    
+
     def redact(self, text: str) -> str:
         """Redact PII from the given text using regex patterns."""
         if not isinstance(text, str):
@@ -98,6 +160,10 @@ class PIIRedactor:
         # Street addresses
         text = self.address_pattern.sub('<REDACTED_ADDRESS>', text)
         
+        # Names
+        text = self.redact_names(text)
+        
+
         # Note: IPs, URLs, usernames, and zipcodes are disabled by default
         # to match JS SDK behavior
         

raindrop_ai-0.0.26/raindrop/version.py

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