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

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

@@ -0,0 +1,248 @@
+"""
+Cache Statistics Score - Single Responsibility: Redis cache monitoring and statistics.
+
+This module handles all cache statistics operations including:
+- Cache hit/miss tracking
+- Cache performance metrics
+- /STATS command processing
+- Cache health monitoring
+"""
+
+from ..models.redis_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 .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']
+            
+            # 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
+            )
+            
+            # Send statistics to user
+            result = await self.messenger.send_text(
+                recipient=user_id,
+                text=stats_message,
+                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
+        """
+        try:
+            # 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")
+            else:
+                # Create new stats
+                stats = CacheStats()
+                stats.cache_type = "Redis"
+                stats.total_operations = 1
+                self.logger.info("📊 Created new cache statistics in table cache")
+            
+            # Test cache connectivity using a simple hash operation
+            try:
+                # Test connectivity by creating a temporary hash (proper Redis usage)
+                test_data = {"test": "connectivity_check", "timestamp": str(stats.last_updated)}
+                test_key = "connectivity_test"
+                
+                # Store test hash in user_cache (proper hash usage)
+                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":
+                    stats.connection_status = "Connected"
+                    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 = "Connection Issues" 
+                    stats.is_healthy = False
+                    stats.errors += 1
+                    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}")
+            return stats
+            
+        except Exception as e:
+            self.logger.error(f"Error collecting cache statistics: {e}")
+            # Return minimal error stats (don't store errors)
+            error_stats = CacheStats()
+            error_stats.cache_type = "Redis (Error)"
+            error_stats.connection_status = f"Collection Error: {str(e)}"
+            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",
+                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"
+            ]
+            
+            return "".join(message)
+            
+        except Exception as e:
+            self.logger.error(f"Error formatting statistics message: {e}")
+            return (
+                "📊 Cache Statistics\n\n"
+                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
+            }
+        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'
+            }

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

@@ -0,0 +1,190 @@
+"""
+Message History Score - Single Responsibility: Message logging and history management.
+
+This module handles all message history operations including:
+- Message logging to table cache
+- Message history retrieval and formatting
+- /HISTORY command processing
+"""
+
+from ..models.redis_demo_models import MessageLog
+from ..utils.cache_utils import create_message_history_key, get_cache_ttl
+from ..utils.message_utils import (
+    extract_command_from_message,
+    extract_user_data,
+    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']
+            
+            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} "
+                    f"({message_log.get_message_count()} messages)"
+                )
+            else:
+                # Create new message history
+                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 Redis with TTL
+            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']
+            
+            # 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(
+                        recent_messages, total_count, 20
+                    )
+                else:
+                    history_text = "📚 Your message history is empty. Start chatting to build your history!"
+            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
+            )
+            
+            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
+        """
+        try:
+            log_key = create_message_history_key(user_id)
+            message_log = await self.table_cache.get(log_key, models=MessageLog)
+            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

wappa/cli/examples/redis_cache_example/app/scores/score_state_commands.py

@@ -0,0 +1,260 @@
+"""
+State Commands Score - Single Responsibility: /WAPPA and /EXIT command processing.
+
+This module handles all state-related commands including:
+- /WAPPA command activation and state management
+- /EXIT command deactivation and cleanup
+- WAPPA state message processing
+"""
+
+from ..models.redis_demo_models import StateHandler
+from ..utils.cache_utils import create_state_key, get_cache_ttl
+from ..utils.message_utils import extract_command_from_message, extract_user_data
+from wappa.webhooks import IncomingMessageWebhook
+
+from .score_base import ScoreBase
+
+
+class StateCommandsScore(ScoreBase):
+    """
+    Handles state-related command processing.
+    
+    Follows Single Responsibility Principle by focusing only
+    on state management and command processing.
+    """
+    
+    async def can_handle(self, webhook: IncomingMessageWebhook) -> bool:
+        """
+        This score handles /WAPPA, /EXIT commands and messages in WAPPA state.
+        
+        Args:
+            webhook: Incoming message webhook
+            
+        Returns:
+            True if this is a state command or user is in WAPPA state
+        """
+        message_text = webhook.get_message_text()
+        if not message_text:
+            return False
+        
+        # Check for state commands
+        command, _ = extract_command_from_message(message_text.strip())
+        if command in ['/WAPPA', '/EXIT']:
+            return True
+        
+        # Check if user is in WAPPA state (need to handle regular messages in state)
+        user_data = extract_user_data(webhook)
+        user_id = user_data['user_id']
+        
+        try:
+            state_key = create_state_key(user_id)
+            state = await self.state_cache.get(state_key, models=StateHandler)
+            return state is not None and state.is_wappa
+        except:
+            return False
+    
+    async def process(self, webhook: IncomingMessageWebhook) -> bool:
+        """
+        Process state commands and WAPPA state messages.
+        
+        Args:
+            webhook: Incoming message webhook
+            
+        Returns:
+            True if processing was successful
+        """
+        if not await self.validate_dependencies():
+            return False
+        
+        try:
+            message_text = webhook.get_message_text()
+            if not message_text:
+                return False
+            
+            command, remaining_text = extract_command_from_message(message_text.strip())
+            user_data = extract_user_data(webhook)
+            user_id = user_data['user_id']
+            
+            if command == "/WAPPA":
+                await self._handle_wappa_activation(webhook, user_id)
+            elif command == "/EXIT":
+                await self._handle_wappa_exit(webhook, user_id)
+            else:
+                # Handle regular message in WAPPA state
+                await self._handle_wappa_state_message(webhook, user_id, message_text)
+            
+            self._record_processing(success=True)
+            return True
+            
+        except Exception as e:
+            await self._handle_error(e, "state_command_processing")
+            return False
+    
+    async def _handle_wappa_activation(self, webhook: IncomingMessageWebhook, user_id: str) -> None:
+        """
+        Handle /WAPPA command activation.
+        
+        Args:
+            webhook: Incoming message webhook
+            user_id: User's phone number ID
+        """
+        try:
+            # Create and save WAPPA state
+            state = StateHandler()
+            state.activate_wappa()
+            
+            # Store state with TTL
+            state_key = create_state_key(user_id)
+            ttl = get_cache_ttl('state')
+            await self.state_cache.set(state_key, state, ttl=ttl)
+            
+            # Mark message as read with typing indicator first
+            await self.messenger.mark_as_read(
+                message_id=webhook.message.message_id,
+                typing=True
+            )
+            
+            # Send activation message
+            activation_message = (
+                "🎉 You are in wappa state, to exit wappa state write /EXIT\n\n"
+                "✨ While in WAPPA state:\n"
+                "• I'll respond with 'Hola Wapp@ ;)' to all your messages\n"
+                "• Your state is cached in Redis\n"
+                "• Write /EXIT to leave WAPPA state"
+            )
+            
+            result = await self.messenger.send_text(
+                recipient=user_id,
+                text=activation_message,
+                reply_to_message_id=webhook.message.message_id
+            )
+            
+            if result.success:
+                self.logger.info(f"✅ WAPPA state activated for {user_id}")
+            else:
+                self.logger.error(f"❌ Failed to send WAPPA activation message: {result.error}")
+                
+        except Exception as e:
+            self.logger.error(f"Error in WAPPA activation: {e}")
+            raise
+    
+    async def _handle_wappa_exit(self, webhook: IncomingMessageWebhook, user_id: str) -> None:
+        """
+        Handle /EXIT command deactivation.
+        
+        Args:
+            webhook: Incoming message webhook
+            user_id: User's phone number ID
+        """
+        try:
+            state_key = create_state_key(user_id)
+            
+            # Check if user has WAPPA state
+            state = await self.state_cache.get(state_key, models=StateHandler)
+            
+            if state and state.is_wappa:
+                # Calculate session stats
+                duration = state.get_state_duration() or 0
+                command_count = state.command_count
+                
+                # Deactivate and delete state
+                await self.state_cache.delete(state_key)
+                
+                # Mark message as read with typing indicator first
+                await self.messenger.mark_as_read(
+                    message_id=webhook.message.message_id,
+                    typing=True
+                )
+                
+                # Send exit message
+                exit_message = (
+                    "👋 You are no longer in wappa state!\n\n"
+                    f"📊 Session Summary:\n"
+                    f"• Duration: {duration} seconds\n"
+                    f"• Commands processed: {command_count}\n"
+                    f"• State cleared from Redis cache"
+                )
+                
+                result = await self.messenger.send_text(
+                    recipient=user_id,
+                    text=exit_message,
+                    reply_to_message_id=webhook.message.message_id
+                )
+                
+                if result.success:
+                    self.logger.info(f"✅ WAPPA state deactivated for {user_id} (duration: {duration}s)")
+                else:
+                    self.logger.error(f"❌ Failed to send WAPPA exit message: {result.error}")
+            else:
+                # No active state found
+                await self.messenger.send_text(
+                    recipient=user_id,
+                    text="❓ You are not currently in WAPPA state. Send /WAPPA to activate it.",
+                    reply_to_message_id=webhook.message.message_id
+                )
+                
+        except Exception as e:
+            self.logger.error(f"Error in WAPPA exit: {e}")
+            raise
+    
+    async def _handle_wappa_state_message(self, webhook: IncomingMessageWebhook, 
+                                        user_id: str, message_text: str) -> None:
+        """
+        Handle regular messages when user is in WAPPA state.
+        
+        Args:
+            webhook: Incoming message webhook
+            user_id: User's phone number ID
+            message_text: Message content
+        """
+        try:
+            state_key = create_state_key(user_id)
+            state = await self.state_cache.get(state_key, models=StateHandler)
+            
+            if state and state.is_wappa:
+                # Update state with command processing
+                state.process_command(message_text)
+                
+                # Save updated state
+                ttl = get_cache_ttl('state')
+                await self.state_cache.set(state_key, state, ttl=ttl)
+                
+                # Mark message as read with typing indicator first
+                await self.messenger.mark_as_read(
+                    message_id=webhook.message.message_id,
+                    typing=True
+                )
+                
+                # Send WAPPA response
+                result = await self.messenger.send_text(
+                    recipient=user_id,
+                    text="Hola Wapp@ ;)",
+                    reply_to_message_id=webhook.message.message_id
+                )
+                
+                if result.success:
+                    self.logger.info(f"✅ WAPPA response sent to {user_id} (command #{state.command_count})")
+                else:
+                    self.logger.error(f"❌ Failed to send WAPPA response: {result.error}")
+            
+        except Exception as e:
+            self.logger.error(f"Error handling WAPPA state message: {e}")
+            raise
+    
+    async def is_user_in_wappa_state(self, user_id: str) -> bool:
+        """
+        Check if user is currently in WAPPA state (for other score modules).
+        
+        Args:
+            user_id: User's phone number ID
+            
+        Returns:
+            True if user is in WAPPA state
+        """
+        try:
+            state_key = create_state_key(user_id)
+            state = await self.state_cache.get(state_key, models=StateHandler)
+            return state is not None and state.is_wappa
+        except Exception as e:
+            self.logger.error(f"Error checking WAPPA state for {user_id}: {e}")
+            return False