velocity-python 0.0.165__tar.gz → 0.0.167__tar.gz

{velocity_python-0.0.165 → velocity_python-0.0.167}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.165
+Version: 0.0.167
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.165 → velocity_python-0.0.167}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.165"
+version = "0.0.167"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.165 → velocity_python-0.0.167}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.165"
+__version__ = version = "0.0.167"
 
 from . import aws
 from . import db

{velocity_python-0.0.165 → velocity_python-0.0.167}/src/velocity/aws/amplify.py

@@ -69,12 +69,37 @@ class AmplifyProject:
         return all_vars
 
     def list_lambda_functions_filtered(self, env_name):
+        """
+        List Lambda functions that belong to this Amplify app and environment.
+        Filters by user:Application tag, checking both exact app name and sanitized version.
+        """
         paginator = self.lambda_client.get_paginator("list_functions")
+        
+        # Create sanitized version (remove dots and special chars for tag comparison)
+        sanitized_app_name = self.app_name.replace(".", "").replace("-", "")
+        
         for page in paginator.paginate():
             for fn in page["Functions"]:
                 name = fn["FunctionName"]
-                if self.app_name in name and env_name in name:
-                    yield fn
+                arn = fn["FunctionArn"]
+                
+                # Check if function matches environment name
+                if env_name not in name:
+                    continue
+                
+                # Try to get tags to verify this belongs to our app
+                try:
+                    tags_response = self.lambda_client.list_tags(Resource=arn)
+                    tags = tags_response.get("Tags", {})
+                    app_tag = tags.get("user:Application", "")
+                    
+                    # Check if tag matches either exact or sanitized app name
+                    if app_tag == self.app_name or app_tag == sanitized_app_name:
+                        yield fn
+                except Exception:
+                    # Fallback to name-based filtering if tags unavailable
+                    if self.app_name in name or sanitized_app_name in name:
+                        yield fn
 
     def update_lambda_function(
         self,

{velocity_python-0.0.165 → velocity_python-0.0.167}/src/velocity/aws/handlers/lambda_handler.py

@@ -1,4 +1,5 @@
 import json
+from typing import Type
 from velocity.aws.handlers.base_handler import BaseHandler
 from velocity.aws.handlers.response import Response
 from . import context
@@ -8,7 +9,12 @@ from . import context
 
 
 class LambdaHandler(BaseHandler):
-    def __init__(self, aws_event, aws_context, context_class=context.Context):
+    def __init__(
+        self, 
+        aws_event, 
+        aws_context, 
+        context_class: Type[context.Context] = context.Context
+    ):
         super().__init__(aws_event, aws_context, context_class)
 
         # LambdaHandler-specific initialization

{velocity_python-0.0.165 → velocity_python-0.0.167}/src/velocity/aws/handlers/mixins/__init__.py

@@ -4,13 +4,11 @@ Mixins for AWS Lambda handlers.
 This package provides reusable mixins for common Lambda handler functionality:
 - ActivityTracker: Standardized activity logging and tracking
 - ErrorHandler: Standardized error handling and notifications
-- StandardMixin: Combined mixin for most common use cases
-- LegacyMixin: Backward-compatible enhanced tracking for existing handlers
+- EnhancedHandlerMixin: Combined activity tracking and error handling with lifecycle hooks
 """
 
 from .activity_tracker import ActivityTracker
 from .error_handler import ErrorHandler
-from .standard_mixin import StandardMixin
-from .legacy_mixin import LegacyMixin
+from .enhanced_handler_mixin import EnhancedHandlerMixin
 
-__all__ = ['ActivityTracker', 'ErrorHandler', 'StandardMixin', 'LegacyMixin']
+__all__ = ['ActivityTracker', 'ErrorHandler', 'EnhancedHandlerMixin']

velocity_python-0.0.165/src/velocity/aws/handlers/mixins/legacy_mixin.py → velocity_python-0.0.167/src/velocity/aws/handlers/mixins/enhanced_handler_mixin.py

@@ -1,8 +1,9 @@
 """
-Legacy Mixin for backward compatibility.
+Enhanced Handler Mixin for Lambda handlers.
 
-Provides enhanced activity tracking while maintaining existing 
-beforeAction/afterAction/onError implementations in handlers.
+Provides comprehensive activity tracking and error handling through enhanced
+lifecycle hooks that work alongside existing beforeAction/afterAction/onError
+implementations in handlers.
 """
 
 import os
@@ -10,15 +11,16 @@ from .activity_tracker import ActivityTracker
 from .error_handler import ErrorHandler
 
 
-class LegacyMixin(ActivityTracker, ErrorHandler):
+class EnhancedHandlerMixin(ActivityTracker, ErrorHandler):
     """
-    Legacy-compatible mixin that enhances existing handlers without breaking them.
+    Enhanced handler mixin providing comprehensive activity tracking and error handling.
     
-    This mixin adds standardized activity tracking and error handling
-    while preserving existing beforeAction/afterAction/onError implementations.
+    This mixin adds standardized activity tracking to aws_api_activity table
+    and error handling (logging, notifications, metrics) through enhanced hooks
+    that preserve existing handler implementations.
     
-    Use this when migrating existing handlers that have complex custom logic
-    in their action methods.
+    Use this for handlers that need full activity/error tracking alongside
+    custom logic in their action methods.
     """
     
     def _enhanced_before_action(self, tx, context):

{velocity_python-0.0.165 → velocity_python-0.0.167}/src/velocity/aws/handlers/mixins/error_handler.py

@@ -21,19 +21,6 @@ class ErrorHandler(ABC):
     and error metrics collection.
     """
     
-    def handle_standard_error(self, tx, context, exception: Exception, tb_string: str):
-        """Handle errors with consistent logging and notification patterns"""
-        
-        # Log to sys_log for centralized logging
-        self.log_error_to_system(tx, context, exception, tb_string)
-        
-        # Determine if this error requires notification
-        if self._should_notify_error(exception):
-            self.send_error_notification(tx, context, exception, tb_string)
-        
-        # Log error metrics for monitoring
-        self.log_error_metrics(tx, context, exception)
-    
     def log_error_to_system(self, tx, context, exception: Exception, tb_string: str):
         """Log error to sys_log table"""
         error_data = {

{velocity_python-0.0.165 → velocity_python-0.0.167}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.165
+Version: 0.0.167
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.165 → velocity_python-0.0.167}/src/velocity_python.egg-info/SOURCES.txt

@@ -22,10 +22,8 @@ src/velocity/aws/handlers/response.py
 src/velocity/aws/handlers/sqs_handler.py
 src/velocity/aws/handlers/mixins/__init__.py
 src/velocity/aws/handlers/mixins/activity_tracker.py
-src/velocity/aws/handlers/mixins/aws_session_mixin.py
+src/velocity/aws/handlers/mixins/enhanced_handler_mixin.py
 src/velocity/aws/handlers/mixins/error_handler.py
-src/velocity/aws/handlers/mixins/legacy_mixin.py
-src/velocity/aws/handlers/mixins/standard_mixin.py
 src/velocity/aws/tests/__init__.py
 src/velocity/aws/tests/test_lambda_handler_json_serialization.py
 src/velocity/aws/tests/test_response.py

velocity_python-0.0.165/src/velocity/aws/handlers/mixins/aws_session_mixin.py

@@ -1,192 +0,0 @@
-"""
-Error Handler Mixin for Lambda Handlers.
-
-Provides standardized error handling, logging, and notification functionality
-for Lambda handlers.
-"""
-
-import copy
-import os
-import pprint
-import time
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional
-
-
-class AwsSessionMixin(ABC):
-    """
-    Mixin class providing standardized error handling for Lambda handlers.
-    
-    Handles error logging to sys_log table, email notifications to administrators,
-    and error metrics collection.
-    """
-    
-    def handle_standard_error(self, tx, context, exception: Exception, tb_string: str):
-        """Handle errors with consistent logging and notification patterns"""
-        
-        # Log to sys_log for centralized logging
-        self.log_error_to_system(tx, context, exception, tb_string)
-        
-        # Determine if this error requires notification
-        if self._should_notify_error(exception):
-            self.send_error_notification(tx, context, exception, tb_string)
-        
-        # Log error metrics for monitoring
-        self.log_error_metrics(tx, context, exception)
-    
-    def log_error_to_system(self, tx, context, exception: Exception, tb_string: str):
-        """Log error to sys_log table"""
-        error_data = {
-            "level": "ERROR",
-            "message": str(exception),
-            "function": f"{self.__class__.__name__}.{context.action()}",
-            "traceback": tb_string,
-            "exception_type": exception.__class__.__name__,
-            "handler_name": self.__class__.__name__,
-            "action": context.action(),
-            "user_branch": os.environ.get("USER_BRANCH", "Unknown"),
-            "function_name": os.environ.get("AWS_LAMBDA_FUNCTION_NAME", "Unknown"),
-            "app_name": os.environ.get("ProjectName", "Unknown"),
-            "user_agent": "AWS Lambda",
-            "device_type": "Lambda",
-            "sys_modified_by": "Lambda",
-        }
-        
-        # Add user context if available
-        try:
-            if hasattr(self, 'current_user') and self.current_user:
-                error_data["user_email"] = self.current_user.get("email_address")
-        except:
-            pass
-            
-        tx.table("sys_log").insert(error_data)
-    
-    def send_error_notification(self, tx, context, exception: Exception, tb_string: str):
-        """Send error notification email to administrators"""
-        try:
-            # Import here to avoid circular dependency
-            from support.app import helpers
-            
-            environment = os.environ.get('USER_BRANCH', 'Unknown').title()
-            function_name = os.environ.get('AWS_LAMBDA_FUNCTION_NAME', 'Unknown')
-            
-            subject = f"{environment} Lambda Error - {function_name}"
-            
-            body = f"""
-Error Details:
-- Handler: {self.__class__.__name__}
-- Action: {context.action()}
-- Exception: {exception.__class__.__name__}
-- Message: {str(exception)}
-- Environment: {environment}
-- Function: {function_name}
-
-Full Traceback:
-{tb_string}
-
-Request Details:
-{self._get_error_context(context)}
-            """
-            
-            sender = self._get_error_notification_sender()
-            recipients = self._get_error_notification_recipients()
-            
-            helpers.sendmail(
-                tx,
-                subject=subject,
-                body=body,
-                html=None,
-                sender=sender,
-                recipient=recipients[0],
-                cc=recipients[1:] if len(recipients) > 1 else None,
-                bcc=None,
-                email_settings_id=1001,
-            )
-        except Exception as email_error:
-            print(f"Failed to send error notification email: {email_error}")
-    
-    def _should_notify_error(self, exception: Exception) -> bool:
-        """Determine if an error should trigger email notifications"""
-        # Don't notify for user authentication errors or validation errors
-        non_notification_types = [
-            "AuthenticationError", 
-            "ValidationError", 
-            "ValueError",
-            "AlertError"
-        ]
-        
-        exception_name = exception.__class__.__name__
-        
-        # Check for authentication-related exceptions
-        if "Authentication" in exception_name or "Auth" in exception_name:
-            return False
-            
-        return exception_name not in non_notification_types
-    
-    @abstractmethod
-    def _get_error_notification_recipients(self) -> list:
-        """
-        Get list of email recipients for error notifications.
-        
-        Must be implemented by the handler class.
-        
-        Returns:
-            List of email addresses to notify when errors occur
-            
-        Example:
-            return ["admin@company.com", "devops@company.com"]
-        """
-        pass
-    
-    @abstractmethod
-    def _get_error_notification_sender(self) -> str:
-        """
-        Get email sender for error notifications.
-        
-        Must be implemented by the handler class.
-        
-        Returns:
-            Email address to use as sender for error notifications
-            
-        Example:
-            return "no-reply@company.com"
-        """
-        pass
-    
-    def _get_error_context(self, context) -> str:
-        """Get sanitized request context for error reporting"""
-        try:
-            postdata = context.postdata()
-            sanitized = copy.deepcopy(postdata)
-            
-            # Remove sensitive data
-            if "payload" in sanitized and isinstance(sanitized["payload"], dict):
-                sanitized["payload"].pop("cognito_user", None)
-                
-            return pprint.pformat(sanitized)
-        except:
-            return "Unable to retrieve request context"
-    
-    def log_error_metrics(self, tx, context, exception: Exception):
-        """Log error metrics for monitoring and alerting"""
-        try:
-            metrics_data = {
-                "metric_type": "error_count",
-                "handler_name": self.__class__.__name__,
-                "action": context.action(),
-                "exception_type": exception.__class__.__name__,
-                "environment": os.environ.get("USER_BRANCH", "Unknown"),
-                "function_name": os.environ.get("AWS_LAMBDA_FUNCTION_NAME", "Unknown"),
-                "timestamp": time.time(),
-                "sys_modified_by": "Lambda"
-            }
-            
-            # Try to insert into metrics table if it exists
-            try:
-                tx.table("lambda_metrics").insert(metrics_data)
-            except:
-                # Metrics table might not exist yet, don't fail error handler
-                pass
-        except:
-            # Don't fail the error handler if metrics logging fails
-            pass

velocity_python-0.0.165/src/velocity/aws/handlers/mixins/standard_mixin.py

@@ -1,73 +0,0 @@
-"""
-Standard Mixin combining ActivityTracker and ErrorHandler.
-
-Provides a single mixin that includes both activity tracking and error handling
-with standardized beforeAction, afterAction, and onError implementations.
-"""
-
-import copy
-import pprint
-from abc import ABC, abstractmethod
-
-from .activity_tracker import ActivityTracker
-from .error_handler import ErrorHandler
-
-
-class StandardMixin(ActivityTracker, ErrorHandler):
-    """
-    Combined mixin providing both activity tracking and error handling.
-    Use this as the primary mixin for Lambda handlers.
-    
-    Provides standard implementations of:
-    - beforeAction: Starts activity tracking + custom logic
-    - afterAction: Records success + custom logic  
-    - onError: Records error + handles notifications + custom logic
-    """
-    
-    def beforeAction(self, tx, context):
-        """Standard beforeAction implementation"""
-        # Start activity tracking
-        self.track_activity_start(tx, context)
-        
-        # Call any custom beforeAction logic
-        self._custom_before_action(tx, context)
-    
-    def afterAction(self, tx, context):
-        """Standard afterAction implementation"""
-        # Update activity tracking with success
-        self.track_activity_success(tx, context)
-        
-        # Call any custom afterAction logic
-        self._custom_after_action(tx, context)
-    
-    def onError(self, tx, context, exc, tb):
-        """Standard onError implementation"""
-        # Convert exc to exception object if it's a string
-        if isinstance(exc, str):
-            exception = Exception(exc)
-        else:
-            exception = exc
-            
-        # Update activity tracking with error
-        self.track_activity_error(tx, context, exception, tb)
-        
-        # Handle error with standard patterns
-        self.handle_standard_error(tx, context, exception, tb)
-        
-        # Call any custom error handling
-        self._custom_error_handler(tx, context, exception, tb)
-    
-    @abstractmethod
-    def _custom_before_action(self, tx, context):
-        """Override this method for handler-specific beforeAction logic"""
-        pass
-    
-    @abstractmethod  
-    def _custom_after_action(self, tx, context):
-        """Override this method for handler-specific afterAction logic"""
-        pass
-    
-    @abstractmethod
-    def _custom_error_handler(self, tx, context, exception, tb):
-        """Override this method for handler-specific error handling"""
-        pass