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

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

@@ -5,61 +5,65 @@ This module provides functions for downloading and uploading media files,
 handling different media types, and managing local media storage.
 """
 
-import asyncio
 import os
 import tempfile
 from pathlib import Path
-from typing import Dict, Optional, Tuple
 
-import aiofiles
 import aiohttp
+
 from wappa.webhooks import IncomingMessageWebhook
 
 
 class MediaHandler:
     """Utility class for handling media operations."""
-    
-    def __init__(self, temp_dir: Optional[str] = None):
+
+    def __init__(self, temp_dir: str | None = None):
         """
         Initialize MediaHandler.
-        
+
         Args:
             temp_dir: Optional temporary directory path for downloads
         """
         self.temp_dir = temp_dir or tempfile.gettempdir()
-        self.session: Optional[aiohttp.ClientSession] = None
-    
+        self.session: aiohttp.ClientSession | None = None
+
     async def __aenter__(self):
         """Async context manager entry."""
         self.session = aiohttp.ClientSession()
         return self
-    
+
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
         if self.session:
             await self.session.close()
-    
-    async def get_media_info_from_webhook(self, webhook: IncomingMessageWebhook) -> Optional[Dict[str, str]]:
+
+    async def get_media_info_from_webhook(
+        self, webhook: IncomingMessageWebhook
+    ) -> dict[str, str] | None:
         """
         Extract media information from webhook.
-        
+
         Args:
             webhook: IncomingMessageWebhook containing media
-            
+
         Returns:
             Dictionary with media info or None if no media found
         """
         message = webhook.message
         message_type = webhook.get_message_type_name().lower()
-        
-        if message_type not in ["image", "video", "audio", "voice", "document", "sticker"]:
+
+        if message_type not in [
+            "image",
+            "video",
+            "audio",
+            "voice",
+            "document",
+            "sticker",
+        ]:
             return None
-        
-        media_info = {
-            "type": message_type,
-            "message_id": message.message_id
-        }
-        
+
+        media_info = {"type": message_type, "message_id": message.message_id}
+
         # Try to extract media ID (different field names possible)
         media_id = None
         for field_name in ["media_id", "id", f"{message_type}_id"]:
@@ -67,51 +71,53 @@ class MediaHandler:
                 media_id = getattr(message, field_name)
                 if media_id:
                     break
-        
+
         if not media_id:
             return None
-        
+
         media_info["media_id"] = media_id
-        
+
         # Extract additional metadata
         if hasattr(message, "mime_type"):
             media_info["mime_type"] = message.mime_type
-        
+
         if hasattr(message, "file_size"):
             media_info["file_size"] = message.file_size
-        
+
         if hasattr(message, "filename"):
             media_info["filename"] = message.filename
-        
+
         if hasattr(message, "caption"):
             media_info["caption"] = message.caption
-        
+
         # For images and videos, get dimensions
         if message_type in ["image", "video"]:
             if hasattr(message, "width"):
                 media_info["width"] = message.width
             if hasattr(message, "height"):
                 media_info["height"] = message.height
-        
+
         # For audio and video, get duration
         if message_type in ["audio", "video", "voice"]:
             if hasattr(message, "duration"):
                 media_info["duration"] = message.duration
-        
+
         return media_info
-    
-    async def download_media_by_id(self, media_id: str, messenger, media_type: str = None) -> Optional[Tuple[str, Dict[str, str]]]:
+
+    async def download_media_by_id(
+        self, media_id: str, messenger, media_type: str = None
+    ) -> tuple[str, dict[str, str]] | None:
         """
         Download media using media_id through WhatsApp API.
-        
+
         Note: This is a placeholder implementation. The actual implementation
         would need to integrate with the WhatsApp Business API to download media.
-        
+
         Args:
             media_id: Media ID from WhatsApp
             messenger: IMessenger instance for API calls
             media_type: Optional media type hint
-            
+
         Returns:
             Tuple of (file_path, metadata) or None if failed
         """
@@ -122,25 +128,27 @@ class MediaHandler:
             # 2. Download the media file
             # 3. Save to temporary location
             # 4. Return file path and metadata
-            
+
             # For now, return None to indicate media download not implemented
             return None
-            
+
         except Exception as e:
             print(f"Error downloading media {media_id}: {e}")
             return None
-    
-    async def upload_local_media(self, file_path: str, media_type: str = None) -> Optional[str]:
+
+    async def upload_local_media(
+        self, file_path: str, media_type: str = None
+    ) -> str | None:
         """
         Upload local media file to get media_id for sending.
-        
+
         Note: This is a placeholder implementation. The actual implementation
         would need to integrate with the WhatsApp Business API media upload endpoint.
-        
+
         Args:
             file_path: Path to local media file
             media_type: Type of media (image, video, audio, document)
-            
+
         Returns:
             Media ID if successful, None if failed
         """
@@ -150,95 +158,110 @@ class MediaHandler:
             # 1. Upload the file to WhatsApp Business API
             # 2. Get the media_id from the response
             # 3. Return the media_id
-            
+
             # For now, return the file path as a placeholder
             if os.path.exists(file_path):
                 return f"local_{os.path.basename(file_path)}"
-            
+
             return None
-            
+
         except Exception as e:
             print(f"Error uploading media {file_path}: {e}")
             return None
-    
+
     def get_local_media_path(self, filename: str, media_subdir: str = None) -> str:
         """
         Get path to local media file.
-        
+
         Args:
             filename: Name of the media file
             media_subdir: Optional subdirectory within media folder
-            
+
         Returns:
             Full path to media file
         """
         # Construct path relative to app directory
         base_dir = Path(__file__).parent.parent  # Go up to app directory
         media_dir = base_dir / "media"
-        
+
         if media_subdir:
             media_dir = media_dir / media_subdir
-        
+
         return str(media_dir / filename)
-    
+
     def media_file_exists(self, filename: str, media_subdir: str = None) -> bool:
         """
         Check if local media file exists.
-        
+
         Args:
             filename: Name of the media file
             media_subdir: Optional subdirectory within media folder
-            
+
         Returns:
             True if file exists, False otherwise
         """
         file_path = self.get_local_media_path(filename, media_subdir)
         return os.path.exists(file_path)
-    
+
     def get_media_type_from_extension(self, filename: str) -> str:
         """
         Determine media type from file extension.
-        
+
         Args:
             filename: Name of the file
-            
+
         Returns:
             Media type string
         """
         extension = Path(filename).suffix.lower()
-        
+
         # Image extensions
-        if extension in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']:
+        if extension in [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"]:
             return "image"
-        
-        # Video extensions  
-        elif extension in ['.mp4', '.avi', '.mov', '.wmv', '.flv', '.webm']:
+
+        # Video extensions
+        elif extension in [".mp4", ".avi", ".mov", ".wmv", ".flv", ".webm"]:
             return "video"
-        
+
         # Audio extensions
-        elif extension in ['.mp3', '.wav', '.aac', '.ogg', '.m4a', '.flac']:
+        elif extension in [".mp3", ".wav", ".aac", ".ogg", ".m4a", ".flac"]:
             return "audio"
-        
+
         # Document extensions
-        elif extension in ['.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.txt']:
+        elif extension in [
+            ".pdf",
+            ".doc",
+            ".docx",
+            ".xls",
+            ".xlsx",
+            ".ppt",
+            ".pptx",
+            ".txt",
+        ]:
             return "document"
-        
+
         # Default
         else:
             return "document"
-    
-    async def send_media_by_file(self, messenger, recipient: str, file_path: str, 
-                                caption: str = None, reply_to_message_id: str = None) -> Dict[str, any]:
+
+    async def send_media_by_file(
+        self,
+        messenger,
+        recipient: str,
+        file_path: str,
+        caption: str = None,
+        reply_to_message_id: str = None,
+    ) -> dict[str, any]:
         """
         Send media file using appropriate messenger method.
-        
+
         Args:
             messenger: IMessenger instance
             recipient: Recipient phone number
             file_path: Path to media file
             caption: Optional caption
             reply_to_message_id: Optional message to reply to
-            
+
         Returns:
             Result dictionary with success status and details
         """
@@ -247,35 +270,35 @@ class MediaHandler:
                 return {
                     "success": False,
                     "error": f"File not found: {file_path}",
-                    "method": "file_not_found"
+                    "method": "file_not_found",
                 }
-            
+
             media_type = self.get_media_type_from_extension(file_path)
-            
+
             # Send using appropriate method based on media type
             if media_type == "image":
                 result = await messenger.send_image(
                     image_source=file_path,
                     recipient=recipient,
                     caption=caption,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             elif media_type == "video":
                 result = await messenger.send_video(
                     video_source=file_path,
                     recipient=recipient,
                     caption=caption,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             elif media_type == "audio":
                 result = await messenger.send_audio(
                     audio_source=file_path,
                     recipient=recipient,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             elif media_type == "document":
                 filename = os.path.basename(file_path)
                 result = await messenger.send_document(
@@ -283,38 +306,47 @@ class MediaHandler:
                     recipient=recipient,
                     filename=filename,
                     caption=caption,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             else:
                 return {
                     "success": False,
                     "error": f"Unsupported media type: {media_type}",
-                    "method": "unsupported_type"
+                    "method": "unsupported_type",
                 }
-            
+
             return {
                 "success": result.success,
-                "message_id": result.message_id if hasattr(result, 'message_id') else None,
-                "error": result.error if hasattr(result, 'error') else None,
+                "message_id": result.message_id
+                if hasattr(result, "message_id")
+                else None,
+                "error": result.error if hasattr(result, "error") else None,
                 "method": f"send_{media_type}",
                 "media_type": media_type,
-                "file_path": file_path
+                "file_path": file_path,
             }
-            
+
         except Exception as e:
             return {
                 "success": False,
                 "error": f"Error sending media: {str(e)}",
                 "method": "exception",
-                "file_path": file_path
+                "file_path": file_path,
             }
-    
-    async def send_media_by_id(self, messenger, recipient: str, media_id: str, 
-                              media_type: str, caption: str = None, reply_to_message_id: str = None) -> Dict[str, any]:
+
+    async def send_media_by_id(
+        self,
+        messenger,
+        recipient: str,
+        media_id: str,
+        media_type: str,
+        caption: str = None,
+        reply_to_message_id: str = None,
+    ) -> dict[str, any]:
         """
         Send media using media_id (relay existing media).
-        
+
         Args:
             messenger: IMessenger instance
             recipient: Recipient phone number
@@ -322,85 +354,87 @@ class MediaHandler:
             media_type: Type of media
             caption: Optional caption
             reply_to_message_id: Optional message to reply to
-            
+
         Returns:
             Result dictionary with success status and details
         """
         try:
             # For relaying media using media_id, we need to use the media_id as source
             # This assumes the messenger can handle media_id as source parameter
-            
+
             if media_type == "image":
                 result = await messenger.send_image(
                     image_source=media_id,  # Using media_id as source
                     recipient=recipient,
                     caption=caption,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             elif media_type == "video":
                 result = await messenger.send_video(
                     video_source=media_id,
                     recipient=recipient,
                     caption=caption,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             elif media_type in ["audio", "voice"]:
                 result = await messenger.send_audio(
                     audio_source=media_id,
                     recipient=recipient,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             elif media_type == "document":
                 result = await messenger.send_document(
                     document_source=media_id,
                     recipient=recipient,
                     caption=caption,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             elif media_type == "sticker":
                 result = await messenger.send_sticker(
                     sticker_source=media_id,
                     recipient=recipient,
-                    reply_to_message_id=reply_to_message_id
+                    reply_to_message_id=reply_to_message_id,
                 )
-            
+
             else:
                 return {
                     "success": False,
                     "error": f"Unsupported media type for relay: {media_type}",
-                    "method": "unsupported_relay_type"
+                    "method": "unsupported_relay_type",
                 }
-            
+
             return {
                 "success": result.success,
-                "message_id": result.message_id if hasattr(result, 'message_id') else None,
-                "error": result.error if hasattr(result, 'error') else None,
+                "message_id": result.message_id
+                if hasattr(result, "message_id")
+                else None,
+                "error": result.error if hasattr(result, "error") else None,
                 "method": f"relay_{media_type}",
                 "media_type": media_type,
-                "media_id": media_id
+                "media_id": media_id,
             }
-            
+
         except Exception as e:
             return {
                 "success": False,
                 "error": f"Error relaying media: {str(e)}",
                 "method": "relay_exception",
-                "media_id": media_id
+                "media_id": media_id,
             }
 
 
 # Convenience functions for direct use
-async def extract_media_info(webhook: IncomingMessageWebhook) -> Optional[Dict[str, str]]:
+async def extract_media_info(webhook: IncomingMessageWebhook) -> dict[str, str] | None:
     """
     Extract media information from webhook (convenience function).
-    
+
     Args:
         webhook: IncomingMessageWebhook to process
-        
+
     Returns:
         Media info dictionary or None
     """
@@ -408,12 +442,17 @@ async def extract_media_info(webhook: IncomingMessageWebhook) -> Optional[Dict[s
     return await handler.get_media_info_from_webhook(webhook)
 
 
-async def send_local_media_file(messenger, recipient: str, filename: str, 
-                               media_subdir: str = None, caption: str = None, 
-                               reply_to_message_id: str = None) -> Dict[str, any]:
+async def send_local_media_file(
+    messenger,
+    recipient: str,
+    filename: str,
+    media_subdir: str = None,
+    caption: str = None,
+    reply_to_message_id: str = None,
+) -> dict[str, any]:
     """
     Send local media file (convenience function).
-    
+
     Args:
         messenger: IMessenger instance
         recipient: Recipient phone number
@@ -421,47 +460,51 @@ async def send_local_media_file(messenger, recipient: str, filename: str,
         media_subdir: Optional subdirectory
         caption: Optional caption
         reply_to_message_id: Optional message to reply to
-        
+
     Returns:
         Result dictionary
     """
     handler = MediaHandler()
     file_path = handler.get_local_media_path(filename, media_subdir)
-    
+
     return await handler.send_media_by_file(
         messenger=messenger,
         recipient=recipient,
         file_path=file_path,
         caption=caption,
-        reply_to_message_id=reply_to_message_id
+        reply_to_message_id=reply_to_message_id,
     )
 
 
-async def relay_webhook_media(messenger, webhook: IncomingMessageWebhook, 
-                             recipient: str, reply_to_message_id: str = None) -> Dict[str, any]:
+async def relay_webhook_media(
+    messenger,
+    webhook: IncomingMessageWebhook,
+    recipient: str,
+    reply_to_message_id: str = None,
+) -> dict[str, any]:
     """
     Relay media from webhook to recipient (convenience function).
-    
+
     Args:
         messenger: IMessenger instance
         webhook: Original webhook with media
-        recipient: Recipient phone number  
+        recipient: Recipient phone number
         reply_to_message_id: Optional message to reply to
-        
+
     Returns:
         Result dictionary
     """
     handler = MediaHandler()
-    
+
     # Extract media info from webhook
     media_info = await handler.get_media_info_from_webhook(webhook)
     if not media_info:
         return {
             "success": False,
             "error": "No media found in webhook",
-            "method": "no_media"
+            "method": "no_media",
         }
-    
+
     # Relay using media_id
     return await handler.send_media_by_id(
         messenger=messenger,
@@ -469,5 +512,5 @@ async def relay_webhook_media(messenger, webhook: IncomingMessageWebhook,
         media_id=media_info["media_id"],
         media_type=media_info["type"],
         caption=media_info.get("caption"),
-        reply_to_message_id=reply_to_message_id
-    )
+        reply_to_message_id=reply_to_message_id,
+    )