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

wappa/__init__.py

@@ -11,19 +11,18 @@ Clean Import Interface (SRP Compliance):
 """
 
 # Framework Essentials Only (SRP: Framework Foundation)
-from .core.wappa_app import Wappa
-from .core.events.event_handler import WappaEventHandler
-from .core.factory import WappaBuilder, WappaPlugin
-
 # Dynamic version from pyproject.toml
 from .core.config.settings import settings
+from .core.events.event_handler import WappaEventHandler
+from .core.factory import WappaBuilder, WappaPlugin
+from .core.wappa_app import Wappa
 
 __version__ = settings.version
 
 __all__ = [
     # Core Framework Components
     "Wappa",
-    "WappaEventHandler", 
+    "WappaEventHandler",
     "WappaBuilder",
     "WappaPlugin",
 ]

wappa/api/controllers/webhook_controller.py

@@ -144,8 +144,9 @@ class WebhookController:
 
         # ENHANCED DEBUGGING: Show context details
         from wappa.core.logging.context import get_context_info
+
         context_info = get_context_info()
-        
+
         self.logger.debug(
             f"Processing webhook for platform: {platform}, owner: {owner_id}"
         )
@@ -395,7 +396,9 @@ class WebhookController:
             factory_class = create_cache_factory(cache_type)
             cache_factory = factory_class(tenant_id=tenant_id, user_id=user_id)
 
-            self.logger.debug(f"✅ Created {cache_factory.__class__.__name__} successfully")
+            self.logger.debug(
+                f"✅ Created {cache_factory.__class__.__name__} successfully"
+            )
             return cache_factory
 
         except Exception as e:

wappa/api/dependencies/__init__.py

@@ -5,11 +5,6 @@ Provides reusable dependencies for controllers, services, and middleware
 following clean architecture patterns.
 """
 
-from functools import lru_cache
-from typing import Annotated
-
-from fastapi import Depends, HTTPException, Request
-
 # Import existing dependencies
 from .whatsapp_dependencies import *
 from .whatsapp_media_dependencies import *

wappa/api/middleware/error_handler.py

@@ -40,11 +40,11 @@ class ErrorHandlerMiddleware(BaseHTTPMiddleware):
 
     async def _log_http_exception(self, request: Request, exc: HTTPException) -> None:
         """Log HTTP exceptions with tenant context."""
-        tenant_id = getattr(request.state, "tenant_id", "unknown")
+        getattr(request.state, "tenant_id", "unknown")
         logger = get_logger(__name__)
 
         # Extract user context from request if available
-        user_id = getattr(request.state, "user_id", "unknown")
+        getattr(request.state, "user_id", "unknown")
 
         logger.warning(
             f"HTTP {exc.status_code} - {request.method} {request.url.path} - "
@@ -55,8 +55,8 @@ class ErrorHandlerMiddleware(BaseHTTPMiddleware):
         self, request: Request, exc: Exception
     ) -> JSONResponse:
         """Handle unexpected exceptions with proper logging and response."""
-        tenant_id = getattr(request.state, "tenant_id", "unknown")
-        user_id = getattr(request.state, "user_id", "unknown")
+        getattr(request.state, "tenant_id", "unknown")
+        getattr(request.state, "user_id", "unknown")
 
         # Get context-aware logger
         logger = get_logger(__name__)

wappa/api/middleware/owner.py

@@ -32,14 +32,16 @@ class OwnerMiddleware(BaseHTTPMiddleware):
 
         try:
             # ENHANCED DEBUGGING: Log all request details
-            logger.debug(f"🔍 OwnerMiddleware processing: {request.method} {request.url.path}")
-            
+            logger.debug(
+                f"🔍 OwnerMiddleware processing: {request.method} {request.url.path}"
+            )
+
             # Extract owner_id from webhook URL pattern: /webhook/messenger/{owner_id}/{platform}
             if request.url.path.startswith("/webhook/"):
                 logger.debug(f"🎯 Webhook request detected: {request.url.path}")
                 path_parts = request.url.path.strip("/").split("/")
                 logger.debug(f"📋 Path parts: {path_parts} (length: {len(path_parts)})")
-                
+
                 if len(path_parts) >= 4:
                     # path_parts = ["webhook", "messenger", "owner_id", "platform"]
                     owner_id = path_parts[2]
@@ -49,14 +51,18 @@ class OwnerMiddleware(BaseHTTPMiddleware):
                     if self._is_valid_owner_id(owner_id):
                         # Set owner_id context from URL
                         set_request_context(owner_id=owner_id)
-                        logger.debug(f"✅ Owner ID context set successfully: {owner_id}")
+                        logger.debug(
+                            f"✅ Owner ID context set successfully: {owner_id}"
+                        )
                     else:
                         logger.error(f"❌ Invalid owner ID format: {owner_id}")
                         raise HTTPException(
                             status_code=400, detail=f"Invalid owner ID: {owner_id}"
                         )
                 else:
-                    logger.warning(f"⚠️ Webhook URL does not have enough parts: {path_parts}")
+                    logger.warning(
+                        f"⚠️ Webhook URL does not have enough parts: {path_parts}"
+                    )
 
             # For non-webhook endpoints, use default owner from settings
             elif not self._is_public_endpoint(request.url.path):

wappa/api/routes/webhooks.py

@@ -161,10 +161,10 @@ def create_webhook_router(event_dispatcher: WappaEventDispatcher) -> APIRouter:
         # Generate webhook URLs for this platform and tenant
         try:
             platform_type = PlatformType(platform.lower())
-        except ValueError:
+        except ValueError as e:
             raise HTTPException(
                 status_code=400, detail=f"Unsupported platform: {platform}"
-            )
+            ) from e
 
         webhook_url = webhook_url_factory.generate_webhook_url(platform_type, tenant_id)
         verify_url = webhook_url_factory.generate_webhook_url(

wappa/cli/__init__.py

@@ -6,4 +6,4 @@ Provides command-line interface for Wappa development and deployment workflows.
 
 from .main import app
 
-__all__ = ["app"]
+__all__ = ["app"]

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

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

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

@@ -1,8 +1,10 @@
 from wappa import WappaEventHandler
 from wappa.webhooks import IncomingMessageWebhook
 
+
 class MasterEventHandler(WappaEventHandler):
-    
     async def process_message(self, webhook: IncomingMessageWebhook):
-        await self.messenger.mark_as_read(webhook.message.message_id, webhook.user.user_id)
-        await self.messenger.send_text("Welcome to Wappa", webhook.user.user_id)
+        await self.messenger.mark_as_read(
+            webhook.message.message_id, webhook.user.user_id
+        )
+        await self.messenger.send_text("Welcome to Wappa", webhook.user.user_id)

wappa/cli/examples/json_cache_example/app/__init__.py

@@ -1 +1 @@
-"""JSON Cache Example - SOLID Architecture Implementation"""
+"""JSON Cache Example - SOLID Architecture Implementation"""

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

@@ -46,28 +46,28 @@ from .master_event import JSONCacheExampleHandler
 def validate_configuration() -> bool:
     """
     Validate required configuration settings.
-    
+
     Returns:
         True if configuration is valid, False otherwise
     """
-    
+
     # Check required WhatsApp credentials
     missing_configs = []
-    
+
     if not settings.wp_access_token:
         missing_configs.append("WP_ACCESS_TOKEN")
-    
+
     if not settings.wp_phone_id:
         missing_configs.append("WP_PHONE_ID")
-        
+
     if not settings.wp_bid:
         missing_configs.append("WP_BID")
-    
+
     if missing_configs:
         logger.error(f"❌ Missing required configuration: {', '.join(missing_configs)}")
         logger.error("💡 Create a .env file with the required credentials")
         return False
-    
+
     logger.info("✅ Configuration validation passed")
     return True
 
@@ -75,14 +75,14 @@ def validate_configuration() -> bool:
 def display_startup_information() -> None:
     """
     Display startup information and demo features.
-    
+
     Shows configuration status, architecture overview,
     and available demo features.
     """
     print(f"🚀 Wappa v{__version__} - JSON Cache Example (SOLID Architecture)")
     print("=" * 80)
     print()
-    
+
     print("🏗️ *SOLID ARCHITECTURE IMPLEMENTATION:*")
     print("  • Single Responsibility: Each score module has one specific concern")
     print("  • Open/Closed: New score modules can be added without modification")
@@ -90,22 +90,28 @@ def display_startup_information() -> None:
     print("  • Interface Segregation: Clean, focused interfaces for each concern")
     print("  • Dependency Inversion: Dependencies injected through abstractions")
     print()
-    
+
     print("📋 *CONFIGURATION STATUS:*")
-    print(f"  • Access Token: {'✅ Configured' if settings.wp_access_token else '❌ Missing'}")
-    print(f"  • Phone ID: {settings.wp_phone_id if settings.wp_phone_id else '❌ Missing'}")
+    print(
+        f"  • Access Token: {'✅ Configured' if settings.wp_access_token else '❌ Missing'}"
+    )
+    print(
+        f"  • Phone ID: {settings.wp_phone_id if settings.wp_phone_id else '❌ Missing'}"
+    )
     print(f"  • Business ID: {'✅ Configured' if settings.wp_bid else '❌ Missing'}")
-    print(f"  • JSON Cache: ✅ No external dependencies required")
-    print(f"  • Environment: {'🛠️ Development' if settings.is_development else '🚀 Production'}")
+    print("  • JSON Cache: ✅ No external dependencies required")
+    print(
+        f"  • Environment: {'🛠️ Development' if settings.is_development else '🚀 Production'}"
+    )
     print()
-    
+
     print("🎯 *SCORE MODULES (BUSINESS LOGIC):*")
     print("  • UserManagementScore: User profile and caching logic")
     print("  • MessageHistoryScore: Message logging and /HISTORY command")
-    print("  • StateCommandsScore: /WAPPA and /EXIT command processing")  
+    print("  • StateCommandsScore: /WAPPA and /EXIT command processing")
     print("  • CacheStatisticsScore: Cache monitoring and /STATS command")
     print()
-    
+
     print("🧪 *DEMO FEATURES:*")
     print("  1. Send any message → User profile created/updated + message logged")
     print("  2. Send '/WAPPA' → Enter special state with cache management")
@@ -114,15 +120,15 @@ def display_startup_information() -> None:
     print("  5. Send '/HISTORY' → View your last 20 messages with timestamps")
     print("  6. Send '/STATS' → View comprehensive cache statistics")
     print()
-    
+
     print("💎 *JSON CACHE ARCHITECTURE:*")
     print("  • user_cache: User profiles stored in {project_root}/cache/users/")
-    print("  • table_cache: Message history in {project_root}/cache/tables/")  
+    print("  • table_cache: Message history in {project_root}/cache/tables/")
     print("  • state_cache: Command state management in {project_root}/cache/states/")
     print("  • TTL Support: Metadata-based expiration with lazy cleanup")
     print("  • File Safety: Atomic write operations prevent corruption")
     print()
-    
+
     print("🔧 *TECHNICAL FEATURES:*")
     print("  • File-based persistence with project root auto-detection")
     print("  • BaseModel JSON serialization with datetime handling")
@@ -139,22 +145,22 @@ def display_startup_information() -> None:
 def create_wappa_application() -> Wappa:
     """
     Create and configure the Wappa application.
-    
+
     This function follows Single Responsibility Principle by focusing
     only on application creation and initial configuration.
-    
+
     Returns:
         Configured Wappa application instance
     """
-    
+
     try:
         # Create Wappa instance with JSON cache
         logger.info("🏗️ Creating Wappa application with JSON cache...")
         app = Wappa(cache="json")
-        
+
         logger.info("✅ Wappa application created successfully")
         return app
-        
+
     except Exception as e:
         logger.error(f"❌ Failed to create Wappa application: {e}")
         raise
@@ -163,51 +169,55 @@ def create_wappa_application() -> Wappa:
 def main() -> None:
     """
     Main application entry point.
-    
+
     Demonstrates SOLID principles in action:
     - Single Responsibility: Each function has one clear purpose
     - Dependency Inversion: Dependencies flow from abstractions
     - Open/Closed: System is open for extension via score modules
     """
-    
+
     logger.info("🚀 Starting JSON Cache Example with SOLID Architecture")
-    
+
     try:
         # Display startup information
         display_startup_information()
-        
+
         # Validate configuration before proceeding
         if not validate_configuration():
-            logger.error("❌ Configuration validation failed - cannot start application")
+            logger.error(
+                "❌ Configuration validation failed - cannot start application"
+            )
             return
-        
+
         # Create Wappa application
         app = create_wappa_application()
-        
+
         # Create and set the SOLID WappaEventHandler implementation
         handler = JSONCacheExampleHandler()
         app.set_event_handler(handler)
-        
-        logger.info("✅ Application initialization completed with SOLID WappaEventHandler")
-        
+
+        logger.info(
+            "✅ Application initialization completed with SOLID WappaEventHandler"
+        )
+
         print("🌐 Starting SOLID JSON cache demo server...")
         print("💡 Press CTRL+C to stop the server")
         print("💾 Cache files will be created in the project's cache/ directory")
         print("=" * 80)
         print()
-        
+
         # Start the application
         # The framework will handle dependency injection automatically
         app.run()
-        
+
     except KeyboardInterrupt:
         logger.info("👋 Application stopped by user")
         print("\n👋 JSON cache demo stopped by user")
-        
+
     except Exception as e:
         logger.error(f"❌ Application startup error: {e}", exc_info=True)
         print(f"\n❌ Server error: {e}")
-        
+
     finally:
         logger.info("🏁 JSON cache demo completed")
         print("🏁 JSON cache demo completed")
@@ -219,17 +229,19 @@ def main() -> None:
 try:
     logger.info("📦 Creating module-level Wappa application instance")
     app = Wappa(cache="json")
-    
+
     # Create and set the SOLID WappaEventHandler implementation
     handler = JSONCacheExampleHandler()
     app.set_event_handler(handler)
-    
-    logger.info("✅ Module-level application instance ready with SOLID WappaEventHandler")
-    
+
+    logger.info(
+        "✅ Module-level application instance ready with SOLID WappaEventHandler"
+    )
+
 except Exception as e:
     logger.error(f"❌ Failed to create module-level app instance: {e}")
     raise
 
 
 if __name__ == "__main__":
-    main()
+    main()