wappa 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

wappa/cli/examples/json_cache_example/app/utils/cache_utils.py

@@ -1,27 +1,25 @@
 """
 Cache utility functions following Single Responsibility Principle.
 
-This module provides cache-related helper functions used across 
+This module provides cache-related helper functions used across
 different score modules for consistent cache management.
 """
 
 import re
-from datetime import datetime
-from typing import Optional
 
 
-def generate_cache_key(prefix: str, identifier: str, suffix: Optional[str] = None) -> str:
+def generate_cache_key(prefix: str, identifier: str, suffix: str | None = None) -> str:
     """
     Generate a standardized cache key.
-    
+
     Args:
         prefix: Cache type prefix (e.g., 'user', 'state', 'msg_history')
         identifier: Unique identifier (e.g., user_id, session_id)
         suffix: Optional suffix for additional specificity
-        
+
     Returns:
         Properly formatted cache key
-        
+
     Examples:
         >>> generate_cache_key('user', '1234567890')
         'user:1234567890'
@@ -30,139 +28,139 @@ def generate_cache_key(prefix: str, identifier: str, suffix: Optional[str] = Non
     """
     if not prefix or not identifier:
         raise ValueError("Both prefix and identifier are required")
-    
+
     # Sanitize inputs
     prefix = sanitize_cache_component(prefix)
     identifier = sanitize_cache_component(identifier)
-    
+
     key = f"{prefix}:{identifier}"
-    
+
     if suffix:
         suffix = sanitize_cache_component(suffix)
         key += f":{suffix}"
-    
+
     return key
 
 
 def sanitize_cache_component(component: str) -> str:
     """
     Sanitize a cache key component by removing invalid characters.
-    
+
     Args:
         component: Component string to sanitize
-        
+
     Returns:
         Sanitized component safe for cache keys
     """
     # Remove spaces and special characters, keep alphanumeric, underscore, hyphen
-    sanitized = re.sub(r'[^\w\-]', '_', str(component).strip())
-    
+    sanitized = re.sub(r"[^\w\-]", "_", str(component).strip())
+
     # Remove multiple consecutive underscores
-    sanitized = re.sub(r'_+', '_', sanitized)
-    
+    sanitized = re.sub(r"_+", "_", sanitized)
+
     # Remove leading/trailing underscores
-    return sanitized.strip('_')
+    return sanitized.strip("_")
 
 
 def get_cache_ttl(cache_type: str) -> int:
     """
     Get standard TTL (time-to-live) values for different cache types.
-    
+
     Args:
         cache_type: Type of cache ('user', 'state', 'message', 'statistics')
-        
+
     Returns:
         TTL in seconds
-        
+
     Raises:
         ValueError: If cache_type is not recognized
     """
     ttl_mapping = {
-        'user': 86400,      # 24 hours - User profiles
-        'state': 3600,      # 1 hour - Command states  
-        'message': 604800,  # 7 days - Message history
-        'statistics': 3600, # 1 hour - Cache statistics
-        'temporary': 600,   # 10 minutes - Temporary data
+        "user": 86400,  # 24 hours - User profiles
+        "state": 3600,  # 1 hour - Command states
+        "message": 604800,  # 7 days - Message history
+        "statistics": 3600,  # 1 hour - Cache statistics
+        "temporary": 600,  # 10 minutes - Temporary data
     }
-    
+
     if cache_type not in ttl_mapping:
-        raise ValueError(f"Unknown cache_type: {cache_type}. Valid types: {list(ttl_mapping.keys())}")
-    
+        raise ValueError(
+            f"Unknown cache_type: {cache_type}. Valid types: {list(ttl_mapping.keys())}"
+        )
+
     return ttl_mapping[cache_type]
 
 
 def validate_cache_key(key: str) -> bool:
     """
     Validate if a cache key follows the expected format.
-    
+
     Args:
         key: Cache key to validate
-        
+
     Returns:
         True if valid, False otherwise
     """
     if not key or not isinstance(key, str):
         return False
-    
+
     # Basic format check: should contain at least one colon
-    if ':' not in key:
+    if ":" not in key:
         return False
-    
+
     # Check for invalid characters (spaces, special chars except : _ -)
-    if re.search(r'[^\w:\-]', key):
+    if re.search(r"[^\w:\-]", key):
         return False
-    
+
     # Should not start or end with colon
-    if key.startswith(':') or key.endswith(':'):
+    if key.startswith(":") or key.endswith(":"):
         return False
-    
+
     # Should not have consecutive colons
-    if '::' in key:
-        return False
-    
-    return True
+    return "::" not in key
 
 
 def create_user_profile_key(user_id: str) -> str:
     """Create standardized user profile cache key."""
-    return generate_cache_key('user', user_id, 'profile')
+    return generate_cache_key("user", user_id, "profile")
 
 
 def create_message_history_key(user_id: str) -> str:
-    """Create standardized message history cache key.""" 
-    return generate_cache_key('msg_history', user_id)
+    """Create standardized message history cache key."""
+    return generate_cache_key("msg_history", user_id)
 
 
-def create_state_key(user_id: str, state_type: str = 'wappa') -> str:
+def create_state_key(user_id: str, state_type: str = "wappa") -> str:
     """Create standardized state cache key."""
-    return generate_cache_key('state', user_id, state_type)
+    return generate_cache_key("state", user_id, state_type)
 
 
-def create_statistics_key(scope: str = 'global') -> str:
+def create_statistics_key(scope: str = "global") -> str:
     """Create standardized cache statistics key."""
-    return generate_cache_key('stats', scope)
+    return generate_cache_key("stats", scope)
 
 
 def format_cache_error(operation: str, key: str, error: Exception) -> str:
     """
     Format cache operation error messages consistently.
-    
+
     Args:
         operation: Cache operation ('get', 'set', 'delete')
         key: Cache key that failed
         error: Exception that occurred
-        
+
     Returns:
         Formatted error message
     """
     return f"Cache {operation} failed for key '{key}': {str(error)}"
 
 
-def log_cache_operation(logger, operation: str, key: str, success: bool, 
-                       duration_ms: Optional[float] = None) -> None:
+def log_cache_operation(
+    logger, operation: str, key: str, success: bool, duration_ms: float | None = None
+) -> None:
     """
     Log cache operations consistently across score modules.
-    
+
     Args:
         logger: Logger instance
         operation: Cache operation performed
@@ -172,5 +170,5 @@ def log_cache_operation(logger, operation: str, key: str, success: bool,
     """
     status = "✅" if success else "❌"
     duration_str = f" ({duration_ms:.1f}ms)" if duration_ms else ""
-    
-    logger.debug(f"{status} Cache {operation}: {key}{duration_str}")
+
+    logger.debug(f"{status} Cache {operation}: {key}{duration_str}")

wappa/cli/examples/json_cache_example/app/utils/message_utils.py

@@ -6,88 +6,87 @@ different score modules for consistent message handling.
 """
 
 from datetime import datetime
-from typing import Dict, Optional, Tuple
 
 from wappa.webhooks import IncomingMessageWebhook
 
 
-def extract_user_data(webhook: IncomingMessageWebhook) -> Dict[str, str]:
+def extract_user_data(webhook: IncomingMessageWebhook) -> dict[str, str]:
     """
     Extract user data from webhook in a standardized format.
-    
+
     Args:
         webhook: Incoming message webhook
-        
+
     Returns:
         Dictionary with standardized user data
     """
     return {
-        'user_id': webhook.user.user_id,
-        'user_name': webhook.user.profile_name or "Unknown User",
-        'tenant_id': webhook.tenant.get_tenant_key(),
-        'message_id': webhook.message.message_id,
+        "user_id": webhook.user.user_id,
+        "user_name": webhook.user.profile_name or "Unknown User",
+        "tenant_id": webhook.tenant.get_tenant_key(),
+        "message_id": webhook.message.message_id,
     }
 
 
 def sanitize_message_text(text: str, max_length: int = 500) -> str:
     """
     Sanitize message text for safe storage and processing.
-    
+
     Args:
         text: Raw message text
         max_length: Maximum allowed length
-        
+
     Returns:
         Sanitized message text
     """
     if not text:
         return ""
-    
+
     # Convert to string and strip whitespace
     sanitized = str(text).strip()
-    
+
     # Truncate if too long
     if len(sanitized) > max_length:
-        sanitized = sanitized[:max_length-3] + "..."
-    
+        sanitized = sanitized[: max_length - 3] + "..."
+
     # Replace problematic characters
-    sanitized = sanitized.replace('\x00', '').replace('\r\n', '\n')
-    
+    sanitized = sanitized.replace("\x00", "").replace("\r\n", "\n")
+
     return sanitized
 
 
-def format_timestamp(dt: datetime, format_type: str = 'display') -> str:
+def format_timestamp(dt: datetime, format_type: str = "display") -> str:
     """
     Format timestamps consistently across the application.
-    
+
     Args:
         dt: Datetime to format
         format_type: Format type ('display', 'compact', 'iso')
-        
+
     Returns:
         Formatted timestamp string
     """
-    if format_type == 'display':
+    if format_type == "display":
         return dt.strftime("%Y-%m-%d %H:%M:%S")
-    elif format_type == 'compact':
+    elif format_type == "compact":
         return dt.strftime("%m/%d %H:%M")
-    elif format_type == 'iso':
+    elif format_type == "iso":
         return dt.isoformat()
     else:
         raise ValueError(f"Unknown format_type: {format_type}")
 
 
-def extract_command_from_message(text: str) -> Tuple[Optional[str], str]:
+def extract_command_from_message(text: str) -> tuple[str | None, str]:
     """
     Extract command and remaining text from message.
-    
+
     Args:
         text: Message text
-        
+
     Returns:
         Tuple of (command, remaining_text)
         Command is None if no command found
-        
+
     Examples:
         >>> extract_command_from_message("/WAPPA hello")
         ("/WAPPA", "hello")
@@ -96,80 +95,80 @@ def extract_command_from_message(text: str) -> Tuple[Optional[str], str]:
     """
     if not text:
         return None, ""
-    
+
     text = text.strip()
-    
+
     # Check if it starts with a command
-    if text.startswith('/'):
-        parts = text.split(' ', 1)
+    if text.startswith("/"):
+        parts = text.split(" ", 1)
         command = parts[0].upper()
         remaining = parts[1] if len(parts) > 1 else ""
         return command, remaining
-    
+
     return None, text
 
 
 def is_special_command(text: str) -> bool:
     """
     Check if message text contains a special command.
-    
+
     Args:
         text: Message text to check
-        
+
     Returns:
         True if text contains a recognized command
     """
     command, _ = extract_command_from_message(text)
-    
+
     if not command:
         return False
-    
+
     # List of recognized commands
-    special_commands = ['/WAPPA', '/EXIT', '/HISTORY', '/HELP', '/STATUS']
-    
+    special_commands = ["/WAPPA", "/EXIT", "/HISTORY", "/HELP", "/STATUS"]
+
     return command in special_commands
 
 
 def get_message_type_display_name(message_type: str) -> str:
     """
     Get human-readable display name for message types.
-    
+
     Args:
         message_type: Technical message type
-        
+
     Returns:
         Human-readable display name
     """
     type_mapping = {
-        'text': 'Text',
-        'image': 'Image',
-        'audio': 'Audio',
-        'video': 'Video',
-        'document': 'Document',
-        'location': 'Location',
-        'contacts': 'Contact',
-        'interactive': 'Interactive',
-        'button': 'Button Response',
-        'list': 'List Response',
-        'sticker': 'Sticker',
+        "text": "Text",
+        "image": "Image",
+        "audio": "Audio",
+        "video": "Video",
+        "document": "Document",
+        "location": "Location",
+        "contacts": "Contact",
+        "interactive": "Interactive",
+        "button": "Button Response",
+        "list": "List Response",
+        "sticker": "Sticker",
     }
-    
+
     return type_mapping.get(message_type.lower(), message_type.title())
 
 
-def create_user_greeting(user_name: Optional[str], message_count: int) -> str:
+def create_user_greeting(user_name: str | None, message_count: int) -> str:
     """
     Create personalized user greeting message.
-    
+
     Args:
         user_name: User's display name (can be None)
         message_count: Number of messages from user
-        
+
     Returns:
         Personalized greeting text
     """
     name = user_name or "there"
-    
+
     if message_count == 1:
         return f"👋 Hello {name}! Welcome to the Redis Cache Demo!"
     elif message_count < 5:
@@ -178,69 +177,75 @@ def create_user_greeting(user_name: Optional[str], message_count: int) -> str:
         return f"👋 Hello {name}! You're becoming a regular here! ({message_count} messages)"
 
 
-def format_message_history_display(messages, total_count: int, display_count: int = 20) -> str:
+def format_message_history_display(
+    messages, total_count: int, display_count: int = 20
+) -> str:
     """
     Format message history for display to user.
-    
+
     Args:
         messages: List of MessageHistory objects
         total_count: Total number of messages in history
         display_count: Number of messages being displayed
-        
+
     Returns:
         Formatted history text
     """
     if not messages:
         return "📚 Your message history is empty. Start chatting to build your history!"
-    
+
     history_text = f"📚 Your Message History ({total_count} total messages):\n\n"
-    
+
     for i, msg_history in enumerate(messages, 1):
-        timestamp_str = format_timestamp(msg_history.timestamp, 'compact')
-        msg_type = f"[{get_message_type_display_name(msg_history.message_type)}]" if msg_history.message_type != "text" else ""
-        
+        timestamp_str = format_timestamp(msg_history.timestamp, "compact")
+        msg_type = (
+            f"[{get_message_type_display_name(msg_history.message_type)}]"
+            if msg_history.message_type != "text"
+            else ""
+        )
+
         # Truncate long messages for display
         display_message = sanitize_message_text(msg_history.message, 50)
-        
+
         history_text += f"{i:2d}. {timestamp_str} {msg_type} {display_message}\n"
-    
+
     if total_count > display_count:
         history_text += f"\n... showing last {display_count} of {total_count} messages"
-    
+
     return history_text
 
 
 def create_cache_info_message(user_profile, cache_stats) -> str:
     """
     Create informational message about cache status.
-    
+
     Args:
         user_profile: User profile data
         cache_stats: Cache statistics data
-        
+
     Returns:
         Formatted cache information message
     """
     info_lines = [
-        f"👤 Your Profile:",
+        "👤 Your Profile:",
         f"• Messages sent: {user_profile.message_count}",
         f"• First seen: {format_timestamp(user_profile.first_seen, 'compact')}",
         f"• Last seen: {format_timestamp(user_profile.last_seen, 'compact')}",
         "",
-        f"🎯 Special Commands:",
-        f"• Send '/WAPPA' to enter special state",
-        f"• Send '/EXIT' to leave special state", 
-        f"• Send '/HISTORY' to see your message history",
+        "🎯 Special Commands:",
+        "• Send '/WAPPA' to enter special state",
+        "• Send '/EXIT' to leave special state",
+        "• Send '/HISTORY' to see your message history",
         "",
-        f"📊 Cache Statistics:",
+        "📊 Cache Statistics:",
         f"• Total operations: {cache_stats.total_operations}",
         f"• User cache hit rate: {cache_stats.get_user_hit_rate():.1%}",
         f"• Active states: {cache_stats.state_cache_active}",
         "",
-        f"💾 This demo showcases Redis caching:",
-        f"• User data cached in user_cache",
-        f"• Message history stored in table_cache per user",
-        f"• Commands tracked in state_cache"
+        "💾 This demo showcases Redis caching:",
+        "• User data cached in user_cache",
+        "• Message history stored in table_cache per user",
+        "• Commands tracked in state_cache",
     ]
-    
-    return "\n".join(info_lines)
+
+    return "\n".join(info_lines)

wappa/cli/examples/openai_transcript/app/main.py

@@ -1,8 +1,9 @@
 from wappa import Wappa
+
 from .master_event import TranscriptEventHandler
 
 app = Wappa()
 app.set_event_handler(TranscriptEventHandler())
 
 if __name__ == "__main__":
-    app.run()
+    app.run()

wappa/cli/examples/openai_transcript/app/master_event.py

@@ -1,44 +1,50 @@
-import tempfile
-import os
+from openai import AsyncOpenAI
 
 from wappa import WappaEventHandler
-from wappa.webhooks import IncomingMessageWebhook
-from wappa.core.logging import get_logger
 from wappa.core.config import settings
-
-from openai import AsyncOpenAI
+from wappa.core.logging import get_logger
+from wappa.webhooks import IncomingMessageWebhook
 
 from .openai_utils import AudioProcessingService
 
-
-
 logger = get_logger("TranscriptEventHandler")
 
+
 class TranscriptEventHandler(WappaEventHandler):
-    
     async def process_message(self, webhook: IncomingMessageWebhook):
-        
-        
         message_type = webhook.get_message_type_name()
 
-        await self.messenger.mark_as_read(webhook.message.message_id, webhook.user.user_id)
-        
+        await self.messenger.mark_as_read(
+            webhook.message.message_id, webhook.user.user_id
+        )
+
         if message_type == "audio":
             audio_id = webhook.message.audio.id
-            
+
             openai_client = AsyncOpenAI(api_key=settings.openai_api_key)
             audio_service = AudioProcessingService(openai_client)
 
             # Option 1: Using tempfile context manager (automatic cleanup)
-            async with self.messenger.media_handler.download_media_tempfile(audio_id) as audio_download:
+            async with self.messenger.media_handler.download_media_tempfile(
+                audio_id
+            ) as audio_download:
                 if audio_download.success:
-                    transcription = await audio_service.transcribe_audio(audio_download.file_path)
-                    await self.messenger.send_text(f"*Transcript:*\n\n{transcription}", webhook.user.user_id)
-                    logger.info(f"Transcribed audio from temp file: {audio_download.file_path}")
+                    transcription = await audio_service.transcribe_audio(
+                        audio_download.file_path
+                    )
+                    await self.messenger.send_text(
+                        f"*Transcript:*\n\n{transcription}", webhook.user.user_id
+                    )
+                    logger.info(
+                        f"Transcribed audio from temp file: {audio_download.file_path}"
+                    )
                 else:
                     logger.error(f"Failed to download audio: {audio_download.error}")
-                    await self.messenger.send_text("Sorry, I couldn't download the audio file.", webhook.user.user_id)
-            
+                    await self.messenger.send_text(
+                        "Sorry, I couldn't download the audio file.",
+                        webhook.user.user_id,
+                    )
+
             # Option 2: Memory-only processing (no files created)
             # Uncomment to use bytes-based processing instead:
             # audio_bytes_result = await self.messenger.media_handler.get_media_as_bytes(audio_id)
@@ -49,5 +55,8 @@ class TranscriptEventHandler(WappaEventHandler):
             # else:
             #     logger.error(f"Failed to download audio: {audio_bytes_result.error}")
             #     await self.messenger.send_text("Sorry, I couldn't download the audio file.", webhook.user.user_id)
-        else:   
-            await self.messenger.send_text("*Hey Wapp@!*\n\nThis app only receives Audio, send a Voice Note for Transcript", webhook.user.user_id)
+        else:
+            await self.messenger.send_text(
+                "*Hey Wapp@!*\n\nThis app only receives Audio, send a Voice Note for Transcript",
+                webhook.user.user_id,
+            )

wappa/cli/examples/openai_transcript/app/openai_utils/__init__.py

@@ -1,3 +1,3 @@
 from .audio_processing import AudioProcessingService
 
-all = ["AudioProcessingService"]
+all = ["AudioProcessingService"]