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

wappa/cli/examples/wappa_full_example/app/models/webhook_metadata.py

@@ -7,13 +7,14 @@ objects to provide comprehensive information about each message type.
 
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from pydantic import BaseModel, Field
 
 
 class MessageType(str, Enum):
     """Supported message types for metadata extraction."""
+
     TEXT = "text"
     IMAGE = "image"
     VIDEO = "video"
@@ -30,33 +31,37 @@ class MessageType(str, Enum):
 
 class BaseMessageMetadata(BaseModel):
     """Base metadata common to all message types."""
+
     message_id: str
     message_type: MessageType
     timestamp: datetime
     user_id: str
-    user_name: Optional[str] = None
+    user_name: str | None = None
     tenant_id: str
     platform: str
-    
+
     # Processing metadata
-    processing_time_ms: Optional[int] = None
+    processing_time_ms: int | None = None
     cache_hit: bool = False
-    
+
     class Config:
         use_enum_values = True
 
 
 class TextMessageMetadata(BaseMessageMetadata):
     """Metadata specific to text messages."""
+
     message_type: MessageType = MessageType.TEXT
     text_content: str
     text_length: int
     has_urls: bool = False
     has_mentions: bool = False
     is_forwarded: bool = False
-    
+
     @classmethod
-    def from_webhook(cls, webhook, processing_time_ms: int = None) -> "TextMessageMetadata":
+    def from_webhook(
+        cls, webhook, processing_time_ms: int = None
+    ) -> "TextMessageMetadata":
         """Create TextMessageMetadata from IncomingMessageWebhook."""
         text_content = webhook.get_message_text() or ""
         return cls(
@@ -71,43 +76,48 @@ class TextMessageMetadata(BaseMessageMetadata):
             has_urls="http" in text_content.lower(),
             has_mentions="@" in text_content,
             is_forwarded=webhook.was_forwarded(),
-            processing_time_ms=processing_time_ms
+            processing_time_ms=processing_time_ms,
         )
 
 
 class MediaMessageMetadata(BaseMessageMetadata):
     """Metadata specific to media messages (image, video, audio, document)."""
+
     media_id: str
     media_type: str
-    file_size: Optional[int] = None
-    mime_type: Optional[str] = None
-    caption: Optional[str] = None
+    file_size: int | None = None
+    mime_type: str | None = None
+    caption: str | None = None
     caption_length: int = 0
     is_forwarded: bool = False
-    
+
     # Media-specific fields
-    width: Optional[int] = None
-    height: Optional[int] = None
-    duration: Optional[int] = None  # For video/audio
-    filename: Optional[str] = None  # For documents
-    
+    width: int | None = None
+    height: int | None = None
+    duration: int | None = None  # For video/audio
+    filename: str | None = None  # For documents
+
     @classmethod
-    def from_webhook(cls, webhook, message_type: MessageType, processing_time_ms: int = None) -> "MediaMessageMetadata":
+    def from_webhook(
+        cls, webhook, message_type: MessageType, processing_time_ms: int = None
+    ) -> "MediaMessageMetadata":
         """Create MediaMessageMetadata from IncomingMessageWebhook."""
         # Extract media information from webhook
-        media_id = getattr(webhook.message, 'media_id', '') or getattr(webhook.message, 'id', '')
-        caption = getattr(webhook.message, 'caption', '') or ''
-        
+        media_id = getattr(webhook.message, "media_id", "") or getattr(
+            webhook.message, "id", ""
+        )
+        caption = getattr(webhook.message, "caption", "") or ""
+
         # Try to get additional media properties
-        mime_type = getattr(webhook.message, 'mime_type', None)
-        file_size = getattr(webhook.message, 'file_size', None)
-        filename = getattr(webhook.message, 'filename', None)
-        
+        mime_type = getattr(webhook.message, "mime_type", None)
+        file_size = getattr(webhook.message, "file_size", None)
+        filename = getattr(webhook.message, "filename", None)
+
         # For images/videos
-        width = getattr(webhook.message, 'width', None)
-        height = getattr(webhook.message, 'height', None)
-        duration = getattr(webhook.message, 'duration', None)
-        
+        width = getattr(webhook.message, "width", None)
+        height = getattr(webhook.message, "height", None)
+        duration = getattr(webhook.message, "duration", None)
+
         return cls(
             message_id=webhook.message.message_id,
             message_type=message_type,
@@ -127,28 +137,31 @@ class MediaMessageMetadata(BaseMessageMetadata):
             height=height,
             duration=duration,
             is_forwarded=webhook.was_forwarded(),
-            processing_time_ms=processing_time_ms
+            processing_time_ms=processing_time_ms,
         )
 
 
 class LocationMessageMetadata(BaseMessageMetadata):
     """Metadata specific to location messages."""
+
     message_type: MessageType = MessageType.LOCATION
     latitude: float
     longitude: float
-    location_name: Optional[str] = None
-    location_address: Optional[str] = None
+    location_name: str | None = None
+    location_address: str | None = None
     is_forwarded: bool = False
-    
+
     @classmethod
-    def from_webhook(cls, webhook, processing_time_ms: int = None) -> "LocationMessageMetadata":
+    def from_webhook(
+        cls, webhook, processing_time_ms: int = None
+    ) -> "LocationMessageMetadata":
         """Create LocationMessageMetadata from IncomingMessageWebhook."""
         # Extract location data from webhook
-        latitude = getattr(webhook.message, 'latitude', 0.0)
-        longitude = getattr(webhook.message, 'longitude', 0.0)
-        location_name = getattr(webhook.message, 'name', None)
-        location_address = getattr(webhook.message, 'address', None)
-        
+        latitude = getattr(webhook.message, "latitude", 0.0)
+        longitude = getattr(webhook.message, "longitude", 0.0)
+        location_name = getattr(webhook.message, "name", None)
+        location_address = getattr(webhook.message, "address", None)
+
         return cls(
             message_id=webhook.message.message_id,
             timestamp=webhook.timestamp,
@@ -161,47 +174,50 @@ class LocationMessageMetadata(BaseMessageMetadata):
             location_name=location_name,
             location_address=location_address,
             is_forwarded=webhook.was_forwarded(),
-            processing_time_ms=processing_time_ms
+            processing_time_ms=processing_time_ms,
         )
 
 
 class ContactMessageMetadata(BaseMessageMetadata):
     """Metadata specific to contact messages."""
+
     message_type: MessageType = MessageType.CONTACT
     contacts_count: int
-    contact_names: List[str] = Field(default_factory=list)
+    contact_names: list[str] = Field(default_factory=list)
     has_phone_numbers: bool = False
     has_emails: bool = False
     is_forwarded: bool = False
-    
+
     @classmethod
-    def from_webhook(cls, webhook, processing_time_ms: int = None) -> "ContactMessageMetadata":
+    def from_webhook(
+        cls, webhook, processing_time_ms: int = None
+    ) -> "ContactMessageMetadata":
         """Create ContactMessageMetadata from IncomingMessageWebhook."""
         # Extract contact data from webhook
-        contacts = getattr(webhook.message, 'contacts', [])
+        contacts = getattr(webhook.message, "contacts", [])
         if not isinstance(contacts, list):
             contacts = [contacts] if contacts else []
-        
+
         contact_names = []
         has_phone_numbers = False
         has_emails = False
-        
+
         for contact in contacts:
             # Extract contact name
-            if hasattr(contact, 'name') and contact.name:
-                if hasattr(contact.name, 'formatted_name'):
+            if hasattr(contact, "name") and contact.name:
+                if hasattr(contact.name, "formatted_name"):
                     contact_names.append(contact.name.formatted_name)
                 else:
                     contact_names.append(str(contact.name))
-            
+
             # Check for phone numbers
-            if hasattr(contact, 'phones') and contact.phones:
+            if hasattr(contact, "phones") and contact.phones:
                 has_phone_numbers = True
-            
+
             # Check for emails
-            if hasattr(contact, 'emails') and contact.emails:
+            if hasattr(contact, "emails") and contact.emails:
                 has_emails = True
-        
+
         return cls(
             message_id=webhook.message.message_id,
             timestamp=webhook.timestamp,
@@ -214,43 +230,50 @@ class ContactMessageMetadata(BaseMessageMetadata):
             has_phone_numbers=has_phone_numbers,
             has_emails=has_emails,
             is_forwarded=webhook.was_forwarded(),
-            processing_time_ms=processing_time_ms
+            processing_time_ms=processing_time_ms,
         )
 
 
 class InteractiveMessageMetadata(BaseMessageMetadata):
     """Metadata specific to interactive messages (button/list selections)."""
+
     message_type: MessageType = MessageType.INTERACTIVE
     interaction_type: str  # button_reply, list_reply
     selection_id: str
-    selection_title: Optional[str] = None
-    context_message_id: Optional[str] = None  # Original message that triggered this
-    
+    selection_title: str | None = None
+    context_message_id: str | None = None  # Original message that triggered this
+
     @classmethod
-    def from_webhook(cls, webhook, processing_time_ms: int = None) -> "InteractiveMessageMetadata":
+    def from_webhook(
+        cls, webhook, processing_time_ms: int = None
+    ) -> "InteractiveMessageMetadata":
         """Create InteractiveMessageMetadata from IncomingMessageWebhook."""
         # Extract interactive data
         selection_id = webhook.get_interactive_selection() or ""
         interaction_type = "unknown"
         selection_title = None
-        
+
         # Try to determine interaction type and get more details
-        if hasattr(webhook.message, 'interactive') and webhook.message.interactive:
+        if hasattr(webhook.message, "interactive") and webhook.message.interactive:
             interactive_data = webhook.message.interactive
-            
-            if hasattr(interactive_data, 'type'):
+
+            if hasattr(interactive_data, "type"):
                 interaction_type = interactive_data.type
-                
+
                 # Get button reply details
-                if interaction_type == "button_reply" and hasattr(interactive_data, 'button_reply'):
+                if interaction_type == "button_reply" and hasattr(
+                    interactive_data, "button_reply"
+                ):
                     button_reply = interactive_data.button_reply
-                    selection_title = getattr(button_reply, 'title', None)
-                
+                    selection_title = getattr(button_reply, "title", None)
+
                 # Get list reply details
-                elif interaction_type == "list_reply" and hasattr(interactive_data, 'list_reply'):
+                elif interaction_type == "list_reply" and hasattr(
+                    interactive_data, "list_reply"
+                ):
                     list_reply = interactive_data.list_reply
-                    selection_title = getattr(list_reply, 'title', None)
-        
+                    selection_title = getattr(list_reply, "title", None)
+
         return cls(
             message_id=webhook.message.message_id,
             timestamp=webhook.timestamp,
@@ -261,23 +284,26 @@ class InteractiveMessageMetadata(BaseMessageMetadata):
             interaction_type=interaction_type,
             selection_id=selection_id,
             selection_title=selection_title,
-            processing_time_ms=processing_time_ms
+            processing_time_ms=processing_time_ms,
         )
 
 
 class UnknownMessageMetadata(BaseMessageMetadata):
     """Metadata for unsupported or unknown message types."""
+
     message_type: MessageType = MessageType.UNKNOWN
-    raw_message_data: Dict[str, Any] = Field(default_factory=dict)
-    
+    raw_message_data: dict[str, Any] = Field(default_factory=dict)
+
     @classmethod
-    def from_webhook(cls, webhook, processing_time_ms: int = None) -> "UnknownMessageMetadata":
+    def from_webhook(
+        cls, webhook, processing_time_ms: int = None
+    ) -> "UnknownMessageMetadata":
         """Create UnknownMessageMetadata from IncomingMessageWebhook."""
         # Capture raw message data for debugging
         raw_data = {}
-        if hasattr(webhook.message, '__dict__'):
+        if hasattr(webhook.message, "__dict__"):
             raw_data = {k: str(v)[:200] for k, v in webhook.message.__dict__.items()}
-        
+
         return cls(
             message_id=webhook.message.message_id,
             timestamp=webhook.timestamp,
@@ -286,16 +312,16 @@ class UnknownMessageMetadata(BaseMessageMetadata):
             tenant_id=webhook.tenant.get_tenant_key(),
             platform=webhook.platform.value,
             raw_message_data=raw_data,
-            processing_time_ms=processing_time_ms
+            processing_time_ms=processing_time_ms,
         )
 
 
 # Union type for all metadata models
 WebhookMetadata = (
-    TextMessageMetadata |
-    MediaMessageMetadata |
-    LocationMessageMetadata |
-    ContactMessageMetadata |
-    InteractiveMessageMetadata |
-    UnknownMessageMetadata
-)
+    TextMessageMetadata
+    | MediaMessageMetadata
+    | LocationMessageMetadata
+    | ContactMessageMetadata
+    | InteractiveMessageMetadata
+    | UnknownMessageMetadata
+)

wappa/cli/examples/wappa_full_example/app/utils/__init__.py

@@ -2,4 +2,4 @@
 Utility modules for the Wappa Full Example application.
 
 Contains utilities for metadata extraction, media handling, and cache operations.
-"""
+"""