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

wappa/messaging/whatsapp/handlers/whatsapp_media_handler.py

@@ -10,9 +10,9 @@ import os
 import tempfile
 import time
 from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, suppress
 from pathlib import Path
-from typing import Any, BinaryIO, AsyncContextManager
+from typing import Any, AsyncContextManager, BinaryIO
 
 from wappa.core.logging.logger import get_logger
 from wappa.domain.interfaces.media_interface import IMediaHandler
@@ -331,7 +331,7 @@ class WhatsAppMediaHandler(IMediaHandler):
 
         Based on existing WhatsAppServiceMedia.download_media() method.
         Implements workflow: GET /MEDIA_ID -> GET /MEDIA_URL
-        
+
         Args:
             media_id: Platform-specific media identifier
             destination_path: Optional path to save file (ignored if use_tempfile=True)
@@ -412,16 +412,20 @@ class WhatsAppMediaHandler(IMediaHandler):
                 # Save to file if destination_path provided or tempfile requested
                 final_path = None
                 is_temp_file = False
-                
+
                 if use_tempfile:
                     # Create temporary file
                     extension_map = self._get_extension_map()
-                    extension = temp_suffix or extension_map.get(response_content_type, "")
-                    
+                    extension = temp_suffix or extension_map.get(
+                        response_content_type, ""
+                    )
+
                     # Create named temporary file
-                    temp_fd, temp_path = tempfile.mkstemp(suffix=extension, prefix="wappa_media_")
+                    temp_fd, temp_path = tempfile.mkstemp(
+                        suffix=extension, prefix="wappa_media_"
+                    )
                     try:
-                        with os.fdopen(temp_fd, 'wb') as temp_file:
+                        with os.fdopen(temp_fd, "wb") as temp_file:
                             temp_file.write(data)
                         final_path = Path(temp_path)
                         is_temp_file = True
@@ -430,12 +434,10 @@ class WhatsAppMediaHandler(IMediaHandler):
                         )
                     except Exception:
                         # Clean up on error
-                        try:
+                        with suppress(Exception):
                             os.unlink(temp_path)
-                        except Exception:
-                            pass
                         raise
-                        
+
                 elif destination_path:
                     # Original destination path logic
                     extension_map = self._get_extension_map()
@@ -466,11 +468,11 @@ class WhatsAppMediaHandler(IMediaHandler):
                     platform=PlatformType.WHATSAPP,
                     tenant_id=self._tenant_id,
                 )
-                
+
                 # Mark as temp file if needed
                 if is_temp_file:
                     result.mark_as_temp_file(cleanup_on_exit=auto_cleanup)
-                    
+
                 return result
 
             finally:
@@ -519,18 +521,16 @@ class WhatsAppMediaHandler(IMediaHandler):
             use_tempfile=True,
             temp_suffix=temp_suffix,
             sender_id=sender_id,
-            auto_cleanup=True
+            auto_cleanup=True,
         )
-        
+
         try:
             yield result
         finally:
             # Context manager cleanup handled by MediaDownloadResult
             result._cleanup_temp_file()
 
-    async def get_media_as_bytes(
-        self, media_id: str
-    ) -> MediaDownloadResult:
+    async def get_media_as_bytes(self, media_id: str) -> MediaDownloadResult:
         """
         Download media as bytes without creating any files.
 
@@ -543,9 +543,7 @@ class WhatsAppMediaHandler(IMediaHandler):
             MediaDownloadResult with file_data bytes (file_path will be None)
         """
         return await self.download_media(
-            media_id=media_id,
-            destination_path=None,
-            use_tempfile=False
+            media_id=media_id, destination_path=None, use_tempfile=False
         )
 
     async def stream_media(

wappa/models/__init__.py

@@ -9,80 +9,73 @@ Clean Architecture: Domain entities and data transfer objects.
 Usage (User Request: Quick access to WhatsApp models for endpoint schemas):
     # Basic message models
     from wappa.models import BasicTextMessage, MessageResult
-    
-    # Interactive models  
+
+    # Interactive models
     from wappa.models import ButtonMessage, ListMessage, CTAMessage
-    
+
     # Media models
     from wappa.models import ImageMessage, VideoMessage, AudioMessage
-    
+
     # Specialized models
     from wappa.models import ContactMessage, LocationMessage
-    
+
     # Template models
     from wappa.models import TextTemplateMessage, MediaTemplateMessage
 """
 
 # Re-export WhatsApp models with cleaner path (User Request: Quick access)
 from ..messaging.whatsapp.models import (
+    AudioMessage,
     # Basic Models
     BasicTextMessage,
-    MessageResult,
-    ReadStatusMessage,
-    
+    BusinessContact,
     # Interactive Models
     ButtonMessage,
-    CTAMessage,
-    ListMessage,
-    
-    # Media Models  
-    MediaType,
-    ImageMessage,
-    VideoMessage,
-    AudioMessage,
-    DocumentMessage,
-    StickerMessage,
-    
     # Specialized Models
     ContactCard,
     ContactMessage,
     ContactValidationResult,
+    CTAMessage,
+    DocumentMessage,
+    ImageMessage,
+    ListMessage,
     LocationMessage,
     LocationRequestMessage,
+    LocationTemplateMessage,
     LocationValidationResult,
-    BusinessContact,
+    MediaTemplateMessage,
+    # Media Models
+    MediaType,
+    MessageResult,
     PersonalContact,
-    
+    ReadStatusMessage,
+    StickerMessage,
+    TemplateMessageStatus,
+    TemplateParameter,
     # Template Models
     TemplateType,
-    TemplateParameter,
-    TextTemplateMessage,
-    MediaTemplateMessage,
-    LocationTemplateMessage,
-    TemplateMessageStatus,
     TemplateValidationResult,
+    TextTemplateMessage,
+    VideoMessage,
 )
 
 __all__ = [
     # Basic Models (User Request: Clean access for endpoint schemas)
     "BasicTextMessage",
-    "MessageResult", 
+    "MessageResult",
     "ReadStatusMessage",
-    
     # Interactive Models
     "ButtonMessage",
     "CTAMessage",
     "ListMessage",
-    
     # Media Models
     "MediaType",
     "ImageMessage",
-    "VideoMessage", 
+    "VideoMessage",
     "AudioMessage",
     "DocumentMessage",
     "StickerMessage",
-    
-    # Specialized Models  
+    # Specialized Models
     "ContactCard",
     "ContactMessage",
     "ContactValidationResult",
@@ -91,13 +84,12 @@ __all__ = [
     "LocationValidationResult",
     "BusinessContact",
     "PersonalContact",
-    
     # Template Models
     "TemplateType",
     "TemplateParameter",
     "TextTemplateMessage",
-    "MediaTemplateMessage", 
+    "MediaTemplateMessage",
     "LocationTemplateMessage",
     "TemplateMessageStatus",
     "TemplateValidationResult",
-]
+]

wappa/persistence/__init__.py

@@ -9,47 +9,44 @@ Clean Architecture: Infrastructure layer with cache and repository abstractions.
 Usage (User Request: Quick access to create_cache_factory):
     # Cache factory (main request)
     from wappa.persistence import create_cache_factory, get_cache_factory
-    
+
     # Cache interfaces
     from wappa.persistence import ICacheFactory, IStateRepository
-    
+
     # Specific implementations
     from wappa.persistence.redis import RedisCacheFactory, RedisClient
-    from wappa.persistence.json import JSONCacheFactory  
+    from wappa.persistence.json import JSONCacheFactory
     from wappa.persistence.memory import MemoryCacheFactory
 """
 
 # Cache Factory Functions (User Request: Quick access to create_cache_factory)
-from .cache_factory import create_cache_factory, get_cache_factory
-
 # Cache Interfaces
 from ..domain.interfaces.cache_factory import ICacheFactory
 from ..domain.interfaces.cache_interface import ICache
-from ..domain.interfaces.state_repository import IStateRepository
-from ..domain.interfaces.user_repository import IUserRepository
-from ..domain.interfaces.tables_repository import ITablesRepository
-from ..domain.interfaces.pubsub_repository import IPubSubRepository
 from ..domain.interfaces.expiry_repository import IExpiryRepository
-from ..domain.interfaces.shared_state_repository import ISharedStateRepository
+from ..domain.interfaces.pubsub_repository import IPubSubRepository
 
 # Repository Factory Interface
 from ..domain.interfaces.repository_factory import IRepositoryFactory
+from ..domain.interfaces.shared_state_repository import ISharedStateRepository
+from ..domain.interfaces.state_repository import IStateRepository
+from ..domain.interfaces.tables_repository import ITablesRepository
+from ..domain.interfaces.user_repository import IUserRepository
+from .cache_factory import create_cache_factory, get_cache_factory
 
 __all__ = [
     # Cache Factory Functions (User Request: Main access point)
     "create_cache_factory",
     "get_cache_factory",
-    
     # Core Interfaces
     "ICacheFactory",
-    "ICache", 
+    "ICache",
     "IRepositoryFactory",
-    
     # Repository Interfaces
     "IStateRepository",
     "IUserRepository",
-    "ITablesRepository", 
+    "ITablesRepository",
     "IPubSubRepository",
     "IExpiryRepository",
     "ISharedStateRepository",
-]
+]

wappa/persistence/cache_factory.py

@@ -4,7 +4,6 @@ Main cache factory selector for Wappa framework.
 Provides factory selector based on cache type configuration.
 """
 
-
 from ..domain.interfaces.cache_factory import ICacheFactory
 
 

wappa/persistence/json/__init__.py

@@ -11,4 +11,4 @@ Usage:
 
 from .json_cache_factory import JSONCacheFactory
 
-__all__ = ["JSONCacheFactory"]
+__all__ = ["JSONCacheFactory"]

wappa/persistence/json/cache_adapters.py

@@ -28,7 +28,9 @@ class JSONStateCacheAdapter(ICache):
         """Get cached data by key."""
         return await self._handler.get(key, models=models)
 
-    async def set(self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None) -> bool:
+    async def set(
+        self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None
+    ) -> bool:
         """Set cached data with optional TTL."""
         return await self._handler.upsert(key, data, ttl=ttl)
 
@@ -84,7 +86,9 @@ class JSONUserCacheAdapter(ICache):
         """Get cached data by key. For user cache, key is ignored as it uses user_id."""
         return await self._handler.get(models=models)
 
-    async def set(self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None) -> bool:
+    async def set(
+        self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None
+    ) -> bool:
         """Set cached data with optional TTL."""
         return await self._handler.upsert(data, ttl=ttl)
 
@@ -131,15 +135,15 @@ class JSONUserCacheAdapter(ICache):
 class JSONTableCacheAdapter(ICache):
     """
     Adapter that makes JSONTable implement ICache interface.
-    
+
     Table Key Format Guide:
     Use create_table_key(table_name, pkid) to generate proper keys.
-    
+
     Examples:
         # Good - using helper method
         key = cache.create_table_key("user_profiles", "12345")
         await cache.set(key, user_data)
-        
+
         # Also supported - manual format
         key = "user_profiles:12345"
         await cache.set(key, user_data)
@@ -147,29 +151,29 @@ class JSONTableCacheAdapter(ICache):
 
     def __init__(self, tenant_id: str):
         self._handler = JSONTable(tenant=tenant_id)
-    
+
     def create_table_key(self, table_name: str, pkid: str) -> str:
         """
         Create a properly formatted table cache key.
-        
+
         Args:
             table_name: Name of the table (e.g., "user_profiles", "message_logs")
             pkid: Primary key ID (e.g., user_id, message_id)
-            
+
         Returns:
             Formatted key string for use with cache methods
-            
+
         Example:
             key = cache.create_table_key("user_profiles", "12345")
             # Returns: "user_profiles:12345"
         """
         if not table_name or not pkid:
             raise ValueError("Both table_name and pkid must be provided and non-empty")
-        
+
         # Sanitize inputs to avoid conflicts
         safe_table_name = str(table_name).replace(":", "_")
         safe_pkid = str(pkid).replace(":", "_")
-        
+
         return f"{safe_table_name}:{safe_pkid}"
 
     async def get(
@@ -179,7 +183,9 @@ class JSONTableCacheAdapter(ICache):
         table_name, pkid = self._parse_key(key)
         return await self._handler.get(table_name, pkid, models=models)
 
-    async def set(self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None) -> bool:
+    async def set(
+        self, key: str, data: dict[str, Any] | BaseModel, ttl: int | None = None
+    ) -> bool:
         """Set cached data with optional TTL."""
         table_name, pkid = self._parse_key(key)
         return await self._handler.upsert(table_name, pkid, data, ttl=ttl)
@@ -236,36 +242,42 @@ class JSONTableCacheAdapter(ICache):
     def _parse_key(self, key: str) -> tuple[str, str]:
         """
         Parse key into table_name and pkid with validation.
-        
+
         Args:
             key: Cache key in format "table_name:pkid"
-            
+
         Returns:
             Tuple of (table_name, pkid)
-            
+
         Raises:
             ValueError: If key format is invalid
         """
         if not key:
             raise ValueError("Key cannot be empty")
-            
+
         if ":" not in key:
             raise ValueError(
                 f"Invalid table cache key format: '{key}'. "
                 f"Expected format: 'table_name:pkid'. "
                 f"Use create_table_key(table_name, pkid) to generate proper keys."
             )
-        
+
         parts = key.split(":", 1)
         if len(parts) != 2:
-            raise ValueError(f"Invalid table cache key format: '{key}'. Expected exactly one ':' separator.")
-            
+            raise ValueError(
+                f"Invalid table cache key format: '{key}'. Expected exactly one ':' separator."
+            )
+
         table_name, pkid = parts
-        
+
         if not table_name.strip():
-            raise ValueError(f"Invalid table cache key: '{key}'. Table name cannot be empty.")
-            
+            raise ValueError(
+                f"Invalid table cache key: '{key}'. Table name cannot be empty."
+            )
+
         if not pkid.strip():
-            raise ValueError(f"Invalid table cache key: '{key}'. Primary key ID cannot be empty.")
-            
-        return table_name.strip(), pkid.strip()
+            raise ValueError(
+                f"Invalid table cache key: '{key}'. Primary key ID cannot be empty."
+            )
+
+        return table_name.strip(), pkid.strip()