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

wappa/cli/examples/json_cache_example/app/scores/score_cache_statistics.py

@@ -8,104 +8,102 @@ This module handles all cache statistics operations including:
 - Cache health monitoring
 """
 
-from ..models.json_demo_models import CacheStats
-from ..utils.cache_utils import get_cache_ttl
-from ..utils.message_utils import extract_command_from_message, extract_user_data
 from wappa.webhooks import IncomingMessageWebhook
 
+from ..models.json_demo_models import CacheStats
+from ..utils.message_utils import extract_command_from_message, extract_user_data
 from .score_base import ScoreBase
 
 
 class CacheStatisticsScore(ScoreBase):
     """
     Handles cache statistics monitoring and reporting operations.
-    
+
     Follows Single Responsibility Principle by focusing only
     on cache performance monitoring and statistics.
     """
-    
+
     async def can_handle(self, webhook: IncomingMessageWebhook) -> bool:
         """
         This score handles /STATS command specifically.
-        
+
         Args:
             webhook: Incoming message webhook
-            
+
         Returns:
             True if this is a /STATS command
         """
         message_text = webhook.get_message_text()
         if not message_text:
             return False
-        
+
         command, _ = extract_command_from_message(message_text.strip())
         return command == "/STATS"
-    
+
     async def process(self, webhook: IncomingMessageWebhook) -> bool:
         """
         Process cache statistics request.
-        
+
         Args:
             webhook: Incoming message webhook
-            
+
         Returns:
             True if processing was successful
         """
         if not await self.validate_dependencies():
             return False
-        
+
         try:
             await self._handle_stats_request(webhook)
             self._record_processing(success=True)
             return True
-            
+
         except Exception as e:
             await self._handle_error(e, "cache_statistics_processing")
             return False
-    
+
     async def _handle_stats_request(self, webhook: IncomingMessageWebhook) -> None:
         """
         Handle /STATS command to show cache statistics.
-        
+
         Args:
             webhook: Incoming message webhook
         """
         try:
             user_data = extract_user_data(webhook)
-            user_id = user_data['user_id']
-            
+            user_id = user_data["user_id"]
+
             # Collect statistics from all cache layers
             stats = await self._collect_cache_statistics()
-            
+
             # Generate statistics report
             stats_message = self._format_statistics_message(stats)
-            
+
             # Mark message as read with typing indicator first
             await self.messenger.mark_as_read(
-                message_id=webhook.message.message_id,
-                typing=True
+                message_id=webhook.message.message_id, typing=True
             )
-            
+
             # Send statistics to user
             result = await self.messenger.send_text(
                 recipient=user_id,
                 text=stats_message,
-                reply_to_message_id=webhook.message.message_id
+                reply_to_message_id=webhook.message.message_id,
             )
-            
+
             if result.success:
                 self.logger.info(f"✅ Cache statistics sent to {user_id}")
             else:
                 self.logger.error(f"❌ Failed to send statistics: {result.error}")
-                
+
         except Exception as e:
             self.logger.error(f"Error handling stats request: {e}")
             raise
-    
+
     async def _collect_cache_statistics(self) -> CacheStats:
         """
         Get or create cache statistics from table cache (persistent storage).
-        
+
         Returns:
             CacheStats object from table cache or newly created
         """
@@ -113,57 +111,70 @@ class CacheStatisticsScore(ScoreBase):
             # Use table cache to store/retrieve statistics (proper table key format)
             # table_name:pkid format as required by table cache
             stats_key = self.table_cache.create_table_key("cache_statistics", "global")
-            
+
             # Try to get existing stats from table cache
             existing_stats = await self.table_cache.get(stats_key, models=CacheStats)
-            
+
             if existing_stats:
                 # Update existing stats
                 stats = existing_stats
                 stats.total_operations += 1  # Increment operation count
                 stats.last_updated = stats.last_updated  # Will auto-update via Pydantic
-                self.logger.debug("📊 Retrieved existing cache statistics from table cache")
+                self.logger.debug(
+                    "📊 Retrieved existing cache statistics from table cache"
+                )
             else:
                 # Create new stats
                 stats = CacheStats()
                 stats.cache_type = "JSON"
                 stats.total_operations = 1
                 self.logger.info("📊 Created new cache statistics in table cache")
-            
+
             # Test cache connectivity using a simple operation
             try:
                 # Test connectivity by creating a temporary data entry
-                test_data = {"test": "connectivity_check", "timestamp": str(stats.last_updated)}
+                test_data = {
+                    "test": "connectivity_check",
+                    "timestamp": str(stats.last_updated),
+                }
                 test_key = "connectivity_test"
-                
+
                 # Store test data in user_cache
                 await self.user_cache.set(test_key, test_data, ttl=5)
                 test_result = await self.user_cache.get(test_key)
-                
-                if test_result and isinstance(test_result, dict) and test_result.get("test") == "connectivity_check":
+
+                if (
+                    test_result
+                    and isinstance(test_result, dict)
+                    and test_result.get("test") == "connectivity_check"
+                ):
                     stats.connection_status = "File System"
                     stats.is_healthy = True
                     # Clean up test key
                     await self.user_cache.delete(test_key)
                     self.logger.debug("✅ Cache connectivity test passed")
                 else:
-                    stats.connection_status = "File System Issues" 
+                    stats.connection_status = "File System Issues"
                     stats.is_healthy = False
                     stats.errors += 1
-                    self.logger.warning(f"⚠️ Cache connectivity test failed: got {test_result}")
-                    
+                    self.logger.warning(
+                        f"⚠️ Cache connectivity test failed: got {test_result}"
+                    )
+
             except Exception as cache_error:
                 self.logger.error(f"Cache connectivity test failed: {cache_error}")
                 stats.connection_status = f"Error: {str(cache_error)}"
                 stats.is_healthy = False
                 stats.errors += 1
-            
+
             # Store updated statistics in table cache (persistent like message history)
             await self.table_cache.set(stats_key, stats)
-            
-            self.logger.info(f"📊 Cache statistics updated in table cache: {stats.connection_status}")
+
+            self.logger.info(
+                f"📊 Cache statistics updated in table cache: {stats.connection_status}"
+            )
             return stats
-            
+
         except Exception as e:
             self.logger.error(f"Error collecting cache statistics: {e}")
             # Return minimal error stats (don't store errors)
@@ -173,50 +184,47 @@ class CacheStatisticsScore(ScoreBase):
             error_stats.is_healthy = False
             error_stats.errors = 1
             return error_stats
-    
+
     def _format_statistics_message(self, stats: CacheStats) -> str:
         """
         Format cache statistics for user display.
-        
+
         Args:
             stats: CacheStats object with collected metrics
-            
+
         Returns:
             Formatted statistics message
         """
         try:
             health_icon = "🟢" if stats.is_healthy else "🔴"
-            
+
             message = [
-                f"📊 *Cache Statistics Report*\n",
+                "📊 *Cache Statistics Report*\n",
                 f"{health_icon} *Cache Status*: {stats.connection_status}\n",
                 f"⚙️ *Cache Type*: {stats.cache_type}\n",
                 f"📈 *Total Operations*: {stats.total_operations}\n",
                 f"❌ *Errors*: {stats.errors}\n",
                 f"🕐 *Last Updated*: {stats.last_updated.strftime('%H:%M:%S')}\n\n",
-                
                 # Cache metrics
                 "*Cache Metrics:*\n",
                 f"• User Cache Hits: {stats.user_cache_hits}\n",
                 f"• User Cache Misses: {stats.user_cache_misses}\n",
                 f"• Table Entries: {stats.table_cache_entries}\n",
                 f"• Active States: {stats.state_cache_active}\n\n",
-                
                 # Performance indicators
                 "*Performance:*\n",
                 f"• Health: {'🟢 Healthy' if stats.is_healthy else '🔴 Unhealthy'}\n",
                 f"• Connection: {stats.connection_status}\n\n",
-                
                 # Tips for users
                 "*Available Commands:*\n",
                 "• `/HISTORY` - View message history\n",
                 "• `/WAPPA` - Enter WAPPA state\n",
                 "• `/EXIT` - Exit WAPPA state\n",
-                "• `/STATS` - View these statistics"
+                "• `/STATS` - View these statistics",
             ]
-            
+
             return "".join(message)
-            
+
         except Exception as e:
             self.logger.error(f"Error formatting statistics message: {e}")
             return (
@@ -224,25 +232,25 @@ class CacheStatisticsScore(ScoreBase):
                 f"❌ Error formatting statistics: {str(e)}\n\n"
                 "Please try again or contact support if the issue persists."
             )
-    
+
     async def get_cache_health(self) -> dict:
         """
         Get cache health status (for other score modules).
-        
+
         Returns:
             Dictionary with cache health information
         """
         try:
             stats = await self._collect_cache_statistics()
             return {
-                'healthy': stats.is_healthy,
-                'status': stats.connection_status,
-                'cache_type': stats.cache_type
+                "healthy": stats.is_healthy,
+                "status": stats.connection_status,
+                "cache_type": stats.cache_type,
             }
         except Exception as e:
             self.logger.error(f"Error getting cache health: {e}")
             return {
-                'healthy': False,
-                'status': f'Health Check Error: {str(e)}',
-                'cache_type': 'Unknown'
-            }
+                "healthy": False,
+                "status": f"Health Check Error: {str(e)}",
+                "cache_type": "Unknown",
+            }

wappa/cli/examples/json_cache_example/app/scores/score_message_history.py

@@ -7,6 +7,8 @@ This module handles all message history operations including:
 - /HISTORY command processing
 """
 
+from wappa.webhooks import IncomingMessageWebhook
+
 from ..models.json_demo_models import MessageLog
 from ..utils.cache_utils import create_message_history_key, get_cache_ttl
 from ..utils.message_utils import (
@@ -15,83 +17,81 @@ from ..utils.message_utils import (
     format_message_history_display,
     sanitize_message_text,
 )
-from wappa.webhooks import IncomingMessageWebhook
-
 from .score_base import ScoreBase
 
 
 class MessageHistoryScore(ScoreBase):
     """
     Handles message history logging and retrieval operations.
-    
+
     Follows Single Responsibility Principle by focusing only
     on message history management.
     """
-    
+
     async def can_handle(self, webhook: IncomingMessageWebhook) -> bool:
         """
         This score handles all messages for logging, plus /HISTORY command.
-        
+
         Args:
             webhook: Incoming message webhook
-            
+
         Returns:
             Always True since all messages should be logged
         """
         return True
-    
+
     async def process(self, webhook: IncomingMessageWebhook) -> bool:
         """
         Process message logging and handle /HISTORY command.
-        
+
         Args:
             webhook: Incoming message webhook
-            
+
         Returns:
             True if processing was successful
         """
         if not await self.validate_dependencies():
             return False
-        
+
         try:
             # Always log the message first
             await self._log_message(webhook)
-            
+
             # Check if this is a /HISTORY command
             message_text = webhook.get_message_text()
             if message_text:
                 command, _ = extract_command_from_message(message_text.strip())
                 if command == "/HISTORY":
                     await self._handle_history_request(webhook)
-            
+
             self._record_processing(success=True)
             return True
-            
+
         except Exception as e:
             await self._handle_error(e, "message_history_processing")
             return False
-    
+
     async def _log_message(self, webhook: IncomingMessageWebhook) -> None:
         """
         Log message to user's message history.
-        
+
         Args:
             webhook: Incoming message webhook
         """
         try:
             user_data = extract_user_data(webhook)
-            user_id = user_data['user_id']
-            tenant_id = user_data['tenant_id']
-            
+            user_id = user_data["user_id"]
+            tenant_id = user_data["tenant_id"]
+
             message_text = webhook.get_message_text()
             message_type = webhook.get_message_type_name()
-            
+
             # Generate cache key using utility function
             log_key = create_message_history_key(user_id)
-            
+
             # Try to get existing message history
             message_log = await self.table_cache.get(log_key, models=MessageLog)
-            
+
             if message_log:
                 self.logger.debug(
                     f"📝 Found existing history for {user_id} "
@@ -99,51 +99,48 @@ class MessageHistoryScore(ScoreBase):
                 )
             else:
                 # Create new message history
-                message_log = MessageLog(
-                    user_id=user_id,
-                    tenant_id=tenant_id
-                )
+                message_log = MessageLog(user_id=user_id, tenant_id=tenant_id)
                 self.logger.info(f"📝 Creating new message history for {user_id}")
-            
+
             # Add the new message to history
             message_content = sanitize_message_text(
                 message_text or f"[{message_type.upper()} MESSAGE]"
             )
             message_log.add_message(message_content, message_type)
-            
+
             # Store back to JSON cache with TTL
-            ttl = get_cache_ttl('message')
+            ttl = get_cache_ttl("message")
             await self.table_cache.set(log_key, message_log, ttl=ttl)
-            
+
             self.logger.info(
                 f"📝 Message logged: {user_id} "
                 f"(total: {message_log.get_message_count()} messages)"
             )
-            
+
         except Exception as e:
             self.logger.error(f"Error logging message: {e}")
             raise
-    
+
     async def _handle_history_request(self, webhook: IncomingMessageWebhook) -> None:
         """
         Handle /HISTORY command to show user's message history.
-        
+
         Args:
             webhook: Incoming message webhook
         """
         try:
             user_data = extract_user_data(webhook)
-            user_id = user_data['user_id']
-            
+            user_id = user_data["user_id"]
+
             # Get user's message history
             log_key = create_message_history_key(user_id)
             message_log = await self.table_cache.get(log_key, models=MessageLog)
-            
+
             if message_log:
                 # User has message history
                 recent_messages = message_log.get_recent_messages(20)
                 total_count = message_log.get_message_count()
-                
+
                 if recent_messages:
                     # Format history for display
                     history_text = format_message_history_display(
@@ -154,30 +151,30 @@ class MessageHistoryScore(ScoreBase):
             else:
                 # No history found
                 history_text = "📚 No message history found. This is your first message! Welcome! 👋"
-            
+
             # Send history to user
             result = await self.messenger.send_text(
                 recipient=user_id,
                 text=history_text,
-                reply_to_message_id=webhook.message.message_id
+                reply_to_message_id=webhook.message.message_id,
             )
-            
+
             if result.success:
                 self.logger.info(f"✅ History sent to {user_id}")
             else:
                 self.logger.error(f"❌ Failed to send history: {result.error}")
-                
+
         except Exception as e:
             self.logger.error(f"Error handling history request: {e}")
             raise
-    
+
     async def get_message_count(self, user_id: str) -> int:
         """
         Get message count for user (for other score modules).
-        
+
         Args:
             user_id: User's phone number ID
-            
+
         Returns:
             Number of messages from user, 0 if no history
         """
@@ -187,4 +184,4 @@ class MessageHistoryScore(ScoreBase):
             return message_log.get_message_count() if message_log else 0
         except Exception as e:
             self.logger.error(f"Error getting message count for {user_id}: {e}")
-            return 0
+            return 0