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

wappa/cli/examples/redis_cache_example/app/models/redis_demo_models.py

@@ -13,32 +13,29 @@ from pydantic import BaseModel, Field, field_validator
 class MessageHistory(BaseModel):
     """
     Individual message entry for message history storage.
-    
+
     Stores a single message with its timestamp.
     """
-    
+
     message: str = Field(
-        ...,
-        description="The message content or type description",
-        max_length=500
+        ..., description="The message content or type description", max_length=500
     )
-    
+
     timestamp: datetime = Field(
-        default_factory=datetime.utcnow,
-        description="When the message was sent"
+        default_factory=datetime.utcnow, description="When the message was sent"
     )
-    
+
     message_type: str = Field(
         default="text",
         description="Type of message (text, image, audio, etc.)",
-        max_length=20
+        max_length=20,
     )
 
 
 class User(BaseModel):
     """
     User profile model for user_cache demonstration.
-    
+
     Stores user information extracted from WhatsApp webhook data.
     """
 
@@ -46,37 +43,30 @@ class User(BaseModel):
         ...,
         description="User's phone number (WhatsApp ID)",
         min_length=10,
-        max_length=20
+        max_length=20,
     )
 
     user_name: str | None = Field(
-        None,
-        description="User's display name from WhatsApp profile",
-        max_length=100
+        None, description="User's display name from WhatsApp profile", max_length=100
     )
 
     first_seen: datetime = Field(
-        default_factory=datetime.utcnow,
-        description="When the user was first seen"
+        default_factory=datetime.utcnow, description="When the user was first seen"
     )
 
     last_seen: datetime = Field(
-        default_factory=datetime.utcnow,
-        description="When the user was last seen"
+        default_factory=datetime.utcnow, description="When the user was last seen"
     )
 
     message_count: int = Field(
-        default=0,
-        description="Total number of messages received from this user",
-        ge=0
+        default=0, description="Total number of messages received from this user", ge=0
     )
 
     is_active: bool = Field(
-        default=True,
-        description="Whether the user is currently active"
+        default=True, description="Whether the user is currently active"
     )
 
-    @field_validator('phone_number', mode='before')
+    @field_validator("phone_number", mode="before")
     @classmethod
     def validate_phone_number(cls, v) -> str:
         """Convert phone number to string if it's an integer."""
@@ -93,7 +83,7 @@ class User(BaseModel):
 class MessageLog(BaseModel):
     """
     Message log model for table_cache demonstration.
-    
+
     Stores message history for a user with waid as primary key.
     Contains a list of all messages sent by the user.
     """
@@ -102,38 +92,35 @@ class MessageLog(BaseModel):
         ...,
         description="User's phone number/ID (primary key)",
         min_length=10,
-        max_length=20
+        max_length=20,
     )
 
     text_message: list[MessageHistory] = Field(
-        default_factory=list,
-        description="List of all messages sent by this user"
+        default_factory=list, description="List of all messages sent by this user"
     )
 
     tenant_id: str | None = Field(
         None,
         description="Tenant/business ID that received the messages",
-        max_length=100
+        max_length=100,
     )
 
     def get_log_key(self) -> str:
         """Generate the primary key for this user's message log."""
         return f"msg_history:{self.user_id}"
-    
+
     def add_message(self, message: str, message_type: str = "text") -> None:
         """Add a new message to the user's history."""
         new_message = MessageHistory(
-            message=message,
-            message_type=message_type,
-            timestamp=datetime.utcnow()
+            message=message, message_type=message_type, timestamp=datetime.utcnow()
         )
         self.text_message.append(new_message)
-    
+
     def get_recent_messages(self, count: int = 10) -> list[MessageHistory]:
         """Get the most recent messages from the user's history."""
         return self.text_message[-count:] if self.text_message else []
-    
-    @field_validator('user_id', 'tenant_id', mode='before')
+
+    @field_validator("user_id", "tenant_id", mode="before")
     @classmethod
     def validate_string_ids(cls, v) -> str:
         """Convert ID fields to string if they're integers."""
@@ -149,30 +136,24 @@ class MessageLog(BaseModel):
 class StateHandler(BaseModel):
     """
     State handler model for state_cache demonstration.
-    
+
     Manages user state for the /WAPPA command flow.
     """
 
     is_wappa: bool = Field(
-        default=False,
-        description="Whether the user is in 'WAPPA' state"
+        default=False, description="Whether the user is in 'WAPPA' state"
     )
 
     activated_at: datetime | None = Field(
-        None,
-        description="When the WAPPA state was activated"
+        None, description="When the WAPPA state was activated"
     )
 
     command_count: int = Field(
-        default=0,
-        description="Number of commands processed while in WAPPA state",
-        ge=0
+        default=0, description="Number of commands processed while in WAPPA state", ge=0
     )
 
     last_command: str | None = Field(
-        None,
-        description="Last command processed in WAPPA state",
-        max_length=100
+        None, description="Last command processed in WAPPA state", max_length=100
     )
 
     def activate_wappa(self) -> None:
@@ -202,7 +183,7 @@ class StateHandler(BaseModel):
 class CacheStats(BaseModel):
     """
     Cache statistics model for monitoring cache usage.
-    
+
     Used to track cache performance and usage statistics.
     """
 
@@ -220,7 +201,7 @@ class CacheStats(BaseModel):
     cache_type: str = Field(default="Unknown")
     connection_status: str = Field(default="Unknown")
     is_healthy: bool = Field(default=True)
-    
+
     # Timing
     last_updated: datetime = Field(default_factory=datetime.utcnow)
 

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

@@ -26,10 +26,10 @@ AVAILABLE_SCORES = [
 
 __all__ = [
     "ScoreBase",
-    "ScoreDependencies", 
+    "ScoreDependencies",
     "UserManagementScore",
     "MessageHistoryScore",
     "StateCommandsScore",
     "CacheStatisticsScore",
     "AVAILABLE_SCORES",
-]
+]

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

@@ -8,7 +8,6 @@ ensuring consistent behavior across different business logic handlers.
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from logging import Logger
-from typing import Optional
 
 from wappa.domain.interfaces.cache_interface import ICache
 from wappa.messaging.whatsapp.messenger.whatsapp_messenger import WhatsAppMessenger
@@ -19,13 +18,14 @@ from wappa.webhooks import IncomingMessageWebhook
 class ScoreDependencies:
     """
     Dependencies required by score modules.
-    
+
     This follows Dependency Inversion Principle by providing
     abstractions that score modules depend on.
     """
+
     messenger: WhatsAppMessenger
     user_cache: ICache
-    table_cache: ICache  
+    table_cache: ICache
     state_cache: ICache
     logger: Logger
 
@@ -33,15 +33,15 @@ class ScoreDependencies:
 class ScoreBase(ABC):
     """
     Base class for all score modules.
-    
+
     Implements Interface Segregation Principle by providing
     only the methods that score modules actually need.
     """
-    
+
     def __init__(self, dependencies: ScoreDependencies):
         """
         Initialize score with injected dependencies.
-        
+
         Args:
             dependencies: Required dependencies for the score
         """
@@ -50,87 +50,94 @@ class ScoreBase(ABC):
         self.table_cache = dependencies.table_cache
         self.state_cache = dependencies.state_cache
         self.logger = dependencies.logger
-        
+
         # Track processing statistics
         self._processing_count = 0
         self._error_count = 0
-    
+
     @property
     def score_name(self) -> str:
         """Return the name of this score module."""
         return self.__class__.__name__
-    
+
     @property
     def processing_stats(self) -> dict:
         """Return processing statistics for this score."""
         return {
-            'processed': self._processing_count,
-            'errors': self._error_count,
-            'success_rate': (
+            "processed": self._processing_count,
+            "errors": self._error_count,
+            "success_rate": (
                 (self._processing_count - self._error_count) / self._processing_count
-                if self._processing_count > 0 else 0.0
-            )
+                if self._processing_count > 0
+                else 0.0
+            ),
         }
-    
+
     @abstractmethod
     async def can_handle(self, webhook: IncomingMessageWebhook) -> bool:
         """
         Determine if this score can handle the given webhook.
-        
+
         Args:
             webhook: Incoming message webhook to evaluate
-            
+
         Returns:
             True if this score should process the webhook
         """
         pass
-    
+
     @abstractmethod
     async def process(self, webhook: IncomingMessageWebhook) -> bool:
         """
         Process the webhook with this score's business logic.
-        
+
         Args:
             webhook: Incoming message webhook to process
-            
+
         Returns:
             True if processing was successful and complete
         """
         pass
-    
+
     async def validate_dependencies(self) -> bool:
         """
         Validate that all required dependencies are available.
-        
+
         Returns:
             True if all dependencies are valid
         """
-        if not all([self.messenger, self.user_cache, self.table_cache, 
-                   self.state_cache, self.logger]):
+        if not all(
+            [
+                self.messenger,
+                self.user_cache,
+                self.table_cache,
+                self.state_cache,
+                self.logger,
+            ]
+        ):
             self.logger.error(f"{self.score_name}: Missing required dependencies")
             return False
         return True
-    
+
     def _record_processing(self, success: bool = True) -> None:
         """Record processing statistics."""
         self._processing_count += 1
         if not success:
             self._error_count += 1
-    
+
     async def _handle_error(self, error: Exception, context: str) -> None:
         """
         Handle errors consistently across score modules.
-        
+
         Args:
             error: Exception that occurred
             context: Context where error occurred
         """
         self._record_processing(success=False)
         self.logger.error(
-            f"{self.score_name} error in {context}: {str(error)}", 
-            exc_info=True
+            f"{self.score_name} error in {context}: {str(error)}", exc_info=True
         )
-    
+
     def __str__(self) -> str:
         """String representation of the score."""
         return f"{self.score_name}(processed={self._processing_count}, errors={self._error_count})"
@@ -139,32 +146,32 @@ class ScoreBase(ABC):
 class ScoreRegistry:
     """
     Registry for managing score modules.
-    
+
     Implements Open/Closed Principle by allowing new scores
     to be registered without modifying existing code.
     """
-    
+
     def __init__(self):
         self._scores: list[ScoreBase] = []
-    
+
     def register_score(self, score: ScoreBase) -> None:
         """Register a score module."""
         if not isinstance(score, ScoreBase):
             raise ValueError("Score must inherit from ScoreBase")
-        
+
         self._scores.append(score)
-    
+
     def get_scores(self) -> list[ScoreBase]:
         """Get all registered scores."""
         return self._scores.copy()
-    
-    async def find_handler(self, webhook: IncomingMessageWebhook) -> Optional[ScoreBase]:
+
+    async def find_handler(self, webhook: IncomingMessageWebhook) -> ScoreBase | None:
         """
         Find the first score that can handle the webhook.
-        
+
         Args:
             webhook: Webhook to find handler for
-            
+
         Returns:
             Score that can handle the webhook, or None
         """
@@ -174,13 +181,12 @@ class ScoreRegistry:
                     return score
             except Exception as e:
                 # Log error but continue to next score
-                score.logger.error(f"Error checking if {score.score_name} can handle webhook: {e}")
-        
+                score.logger.error(
+                    f"Error checking if {score.score_name} can handle webhook: {e}"
+                )
+
         return None
-    
+
     def get_score_stats(self) -> dict:
         """Get statistics for all registered scores."""
-        return {
-            score.score_name: score.processing_stats 
-            for score in self._scores
-        }
+        return {score.score_name: score.processing_stats for score in self._scores}