velocity-python 0.0.116__tar.gz → 0.0.117__tar.gz

{velocity_python-0.0.116 → velocity_python-0.0.117}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.116
+Version: 0.0.117
 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.116 → velocity_python-0.0.117}/pyproject.toml

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

{velocity_python-0.0.116 → velocity_python-0.0.117}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.116"
+__version__ = version = "0.0.117"
 
 from . import aws
 from . import db

{velocity_python-0.0.116 → velocity_python-0.0.117}/src/velocity/aws/amplify.py

@@ -320,12 +320,17 @@ class AmplifyProject:
             "Effect": "Allow",
             "Resource": "*",
             "Action": [
-                "ec2:DescribeInstances",
+  "ec2:DescribeInstances",
                 "ec2:CreateNetworkInterface",
                 "ec2:AttachNetworkInterface",
-                "ec2:DescribeNetworkInterfaces",
+                "ec2:DescribeNetworkInterfaces", 
                 "ec2:DeleteNetworkInterface",
-                "cognito-idp:*",
+                "ec2:DescribeSecurityGroups",
+                "ec2:AuthorizeSecurityGroupIngress",
+                "ec2:AuthorizeSecurityGroupEgress",
+                "ec2:RevokeSecurityGroupIngress",
+                "ec2:RevokeSecurityGroupEgress",
+                "cognito-idp:*"
             ],
         }
     ],

velocity_python-0.0.117/src/velocity/aws/handlers/base_handler.py

@@ -0,0 +1,245 @@
+"""
+Base Handler Module
+
+This module provides a base class for handling AWS Lambda events.
+It includes common functionality shared between LambdaHandler and SqsHandler.
+"""
+
+import os
+import sys
+import traceback
+from typing import Any, Dict, List, Optional
+
+from velocity.aws.handlers import context as VelocityContext
+
+
+class BaseHandler:
+    """
+    Base class for handling AWS Lambda events.
+
+    Provides common functionality including action routing, logging,
+    and error handling hooks that can be shared across different handler types.
+    """
+
+    def __init__(
+        self,
+        aws_event: Dict[str, Any],
+        aws_context: Any,
+        context_class=VelocityContext.Context,
+    ):
+        """
+        Initialize the base handler.
+
+        Args:
+            aws_event: The AWS Lambda event
+            aws_context: The AWS Lambda context object
+            context_class: The context class to use for processing
+        """
+        self.aws_event = aws_event
+        self.aws_context = aws_context
+        self.serve_action_default = True  # Set to False to disable OnActionDefault
+        self.skip_action = False  # Set to True to skip all actions
+        self.ContextClass = context_class
+
+        # Configure SSL certificates for HTTPS requests
+        self._update_lambda_ca_certificates()
+
+    def _update_lambda_ca_certificates(self):
+        """Configure SSL certificates for HTTPS requests in Lambda environments."""
+        # This is helpful for running HTTPS clients on lambda.
+        if os.path.exists("/opt/python/ca-certificates.crt"):
+            os.environ["REQUESTS_CA_BUNDLE"] = "/opt/python/ca-certificates.crt"
+        elif os.path.exists("/home/ubuntu/PyLibLayer/ca-certificates.crt"):
+            os.environ["REQUESTS_CA_BUNDLE"] = (
+                "/home/ubuntu/PyLibLayer/ca-certificates.crt"
+            )
+
+    def get_calling_function(self) -> str:
+        """
+        Get the name of the calling function by inspecting the call stack.
+
+        Returns:
+            The name of the calling function or "<Unknown>" if not found
+        """
+        skip_functions = {"x", "log", "_transaction", "get_calling_function"}
+
+        for idx in range(10):  # Limit search to prevent infinite loops
+            try:
+                frame = sys._getframe(idx)
+                function_name = frame.f_code.co_name
+
+                if function_name not in skip_functions:
+                    return function_name
+
+            except ValueError:
+                # No more frames in the stack
+                break
+
+        return "<Unknown>"
+
+    def format_action_name(self, action: str) -> str:
+        """
+        Format an action string into a method name.
+
+        Args:
+            action: The raw action string (e.g., "create-user", "delete_item")
+
+        Returns:
+            Formatted method name (e.g., "OnActionCreateUser", "OnActionDeleteItem")
+        """
+        if not action:
+            return ""
+
+        formatted = action.replace("-", " ").replace("_", " ")
+        return f"on action {formatted}".title().replace(" ", "")
+
+    def get_actions_to_execute(self, action: Optional[str]) -> List[str]:
+        """
+        Get the list of actions to execute.
+
+        Args:
+            action: The specific action to execute, if any
+
+        Returns:
+            List of action method names to try executing
+        """
+        actions = []
+
+        # Add specific action if available
+        if action:
+            action_method = self.format_action_name(action)
+            actions.append(action_method)
+
+        # Add default action if enabled
+        if self.serve_action_default:
+            actions.append("OnActionDefault")
+
+        return actions
+
+    def execute_actions(self, local_context, actions: List[str]) -> bool:
+        """
+        Execute the appropriate actions for the given context.
+
+        Args:
+            local_context: The context object
+            actions: List of action method names to try
+
+        Returns:
+            True if an action was executed, False otherwise
+        """
+        # Execute beforeAction hook if available
+        if hasattr(self, "beforeAction"):
+            self.beforeAction(local_context)
+
+        action_executed = False
+
+        # Execute the first matching action
+        for action in actions:
+            if self.skip_action:
+                break
+
+            if hasattr(self, action):
+                result = getattr(self, action)(local_context)
+
+                # Check for deprecated return values (LambdaHandler specific)
+                if result is not None and hasattr(self, "_check_deprecated_return"):
+                    self._check_deprecated_return(action, result)
+
+                action_executed = True
+                break
+
+        # Execute afterAction hook if available
+        if hasattr(self, "afterAction"):
+            self.afterAction(local_context)
+
+        return action_executed
+
+    def handle_error(self, local_context, exception: Exception):
+        """
+        Handle errors that occur during action execution.
+
+        Args:
+            local_context: The context object
+            exception: The exception that occurred
+        """
+        if hasattr(self, "onError"):
+            self.onError(
+                local_context,
+                exc=exception.__class__.__name__,
+                tb=traceback.format_exc(),
+            )
+        else:
+            # Re-raise if no error handler is defined
+            raise
+
+    def log(self, tx, message: str, function: Optional[str] = None):
+        """
+        Log a message to the system log table.
+        This is a base implementation that should be overridden by subclasses
+        to provide handler-specific logging details.
+
+        Args:
+            tx: Database transaction object
+            message: The message to log
+            function: Optional function name, auto-detected if not provided
+        """
+        if not function:
+            function = self.get_calling_function()
+
+        # Base log data - subclasses should extend this
+        data = {
+            "app_name": os.environ.get("ProjectName", "Unknown"),
+            "function": function,
+            "message": message,
+        }
+
+        # Let subclasses add their specific fields
+        self._extend_log_data(data)
+
+        tx.table("sys_log").insert(data)
+
+    def _extend_log_data(self, data: Dict[str, Any]):
+        """
+        Extend log data with handler-specific fields.
+        To be overridden by subclasses.
+
+        Args:
+            data: The base log data dictionary to extend
+        """
+        # Default implementation adds basic Lambda info
+        data.update(
+            {
+                "user_agent": "AWS Lambda",
+                "device_type": "Lambda",
+                "sys_modified_by": "Lambda",
+            }
+        )
+
+    def OnActionDefault(self, local_context):
+        """
+        Default action handler when no specific action is found.
+
+        Args:
+            local_context: The context object
+        """
+        action = getattr(local_context, "action", lambda: "unknown")()
+        warning_message = (
+            f"[Warn] Action handler not found. Calling default action "
+            f"`{self.__class__.__name__}.OnActionDefault` with the following parameters:\n"
+            f"  - action: {action}\n"
+            f"  - handler: {self.__class__.__name__}"
+        )
+        print(warning_message)
+
+    def get_context_args(self) -> Dict[str, Any]:
+        """
+        Get the arguments to pass to the context constructor.
+        To be implemented by subclasses based on their specific needs.
+
+        Returns:
+            Dictionary of arguments for context initialization
+        """
+        return {
+            "aws_event": self.aws_event,
+            "aws_context": self.aws_context,
+        }

{velocity_python-0.0.116 → velocity_python-0.0.117}/src/velocity/aws/handlers/context.py

@@ -77,7 +77,7 @@ class Context:
 
     def update_job(self, tx, data=None):
         """Update job status and message in aws_job_activity table.
-        
+
         This method only UPDATES existing jobs. For creating new jobs, use create_job.
         """
         if not data:
@@ -85,11 +85,15 @@ class Context:
         if self.postdata("job_id"):
             # Sanitize data before storing in database
             sanitized_data = self._sanitize_job_data(data)
-            tx.table("aws_job_activity").update(sanitized_data, {"job_id": self.postdata("job_id")})
+            tx.table("aws_job_activity").update(
+                sanitized_data, {"job_id": self.postdata("job_id")}
+            )
             tx.commit()
-            
-    def create_job(self, job_data):
+
+    def create_job(self, tx, job_data=None):
         """Create a new job record in aws_job_activity table using independent transaction."""
+        if not job_data:
+            return
         sanitized_data = self._sanitize_job_data(job_data)
         tx.table("aws_job_activity").insert(sanitized_data)
         tx.commit()
@@ -98,60 +102,71 @@ class Context:
         """Sanitize sensitive data before storing in aws_job_activity table."""
         if not isinstance(data, dict):
             return data
-            
+
         sanitized = {}
-        
+
         # List of sensitive field patterns to sanitize
         sensitive_patterns = [
-            'password', 'token', 'secret', 'key', 'credential', 'auth',
-            'cognito_user', 'session', 'cookie', 'authorization'
+            "password",
+            "token",
+            "secret",
+            "key",
+            "credential",
+            "auth",
+            "cognito_user",
+            "session",
+            "cookie",
+            "authorization",
         ]
-        
+
         for key, value in data.items():
             # Check if key contains sensitive patterns
             if any(pattern in key.lower() for pattern in sensitive_patterns):
                 sanitized[key] = "[REDACTED]" if value else value
-            elif key == 'error' and value:
+            elif key == "error" and value:
                 # Sanitize error messages - keep first 500 chars and remove potential sensitive info
                 error_str = str(value)[:500]
                 for pattern in sensitive_patterns:
                     if pattern in error_str.lower():
                         # Replace potential sensitive values with placeholder
                         import re
+
                         # Remove patterns like password=value, token=value, etc.
                         error_str = re.sub(
-                            rf'{pattern}[=:]\s*[^\s,\]}}]+', 
-                            f'{pattern}=[REDACTED]', 
-                            error_str, 
-                            flags=re.IGNORECASE
+                            rf"{pattern}[=:]\s*[^\s,\]}}]+",
+                            f"{pattern}=[REDACTED]",
+                            error_str,
+                            flags=re.IGNORECASE,
                         )
                 sanitized[key] = error_str
-            elif key == 'traceback' and value:
+            elif key == "traceback" and value:
                 # Sanitize traceback - keep structure but remove sensitive values
                 tb_str = str(value)
                 for pattern in sensitive_patterns:
                     if pattern in tb_str.lower():
                         import re
+
                         # Remove patterns like password=value, token=value, etc.
                         tb_str = re.sub(
-                            rf'{pattern}[=:]\s*[^\s,\]}}]+', 
-                            f'{pattern}=[REDACTED]', 
-                            tb_str, 
-                            flags=re.IGNORECASE
+                            rf"{pattern}[=:]\s*[^\s,\]}}]+",
+                            f"{pattern}=[REDACTED]",
+                            tb_str,
+                            flags=re.IGNORECASE,
                         )
                 # Limit traceback size to prevent DB bloat
                 sanitized[key] = tb_str[:2000]
-            elif key == 'message' and value:
+            elif key == "message" and value:
                 # Sanitize message field
                 message_str = str(value)
                 for pattern in sensitive_patterns:
                     if pattern in message_str.lower():
                         import re
+
                         message_str = re.sub(
-                            rf'{pattern}[=:]\s*[^\s,\]}}]+', 
-                            f'{pattern}=[REDACTED]', 
-                            message_str, 
-                            flags=re.IGNORECASE
+                            rf"{pattern}[=:]\s*[^\s,\]}}]+",
+                            f"{pattern}=[REDACTED]",
+                            message_str,
+                            flags=re.IGNORECASE,
                         )
                 sanitized[key] = message_str[:1000]  # Limit message size
             else:
@@ -163,13 +178,13 @@ class Context:
                     sanitized[key] = value[:5000] + "...[TRUNCATED]"
                 else:
                     sanitized[key] = value
-                    
+
         return sanitized
 
     def enqueue(self, action, payload={}, user=None, suppress_job_activity=False):
         """
         Enqueue jobs to SQS with independent job activity tracking.
-        
+
         This method uses its own transaction for aws_job_activity updates to ensure
         job tracking is never rolled back with other operations.
         """
@@ -181,7 +196,7 @@ class Context:
         if isinstance(payload, dict):
             payload = [payload]
         messages = []
-        if user==None:
+        if user == None:
             user = self.session.get("email_address") or "EnqueueTasks"
         for item in payload:
             message = {"action": action, "payload": item}
@@ -191,26 +206,28 @@ class Context:
             else:
                 message["job_id"] = id
                 # Use separate transaction for job activity - this should never be rolled back
-                self.create_job({
-                    "action": action,
-                    "initial_timestamp": datetime.now(),
-                    "created_by": user,
-                    "sys_modified_by": user,
-                    "payload": to_json(message),
-                    "batch_id": str(batch_id),
-                    "job_id": id,
-                    "status": "Initialized",
-                    "message": f"Job Initialized"
-                })
+                self.create_job(
+                    {
+                        "action": action,
+                        "initial_timestamp": datetime.now(),
+                        "created_by": user,
+                        "sys_modified_by": user,
+                        "payload": to_json(message),
+                        "batch_id": str(batch_id),
+                        "job_id": id,
+                        "status": "Initialized",
+                        "message": f"Job Initialized",
+                    }
+                )
                 messages.append({"Id": id, "MessageBody": to_json(message)})
-            
+
             if len(messages) == 10:
                 result = queue.send_messages(Entries=messages)
                 results = deep_merge(results, result)
                 messages.clear()
-        
+
         if messages:
             result = queue.send_messages(Entries=messages)
             results = deep_merge(results, result)
-        
+
         return results

velocity_python-0.0.117/src/velocity/aws/handlers/exceptions.py

@@ -0,0 +1,16 @@
+class AppError(Exception):
+    pass
+
+
+class AccessError(AppError):
+    pass
+
+
+class AlertError(AppError):
+    def get_payload(self):
+        data = self.args[0]
+        if isinstance(data, str):
+            return {"message": data}
+        elif isinstance(data, dict):
+            return data
+        return {"message": "No message was supplied to AlertError"}

{velocity_python-0.0.116 → velocity_python-0.0.117}/src/velocity/aws/handlers/lambda_handler.py

@@ -3,21 +3,20 @@ import json
 import sys
 import os
 import traceback
-from support.app import DEBUG
-from support.app import helpers, AlertError
-
-from velocity.aws.handlers import Response
-
+from velocity.aws.handlers.base_handler import BaseHandler
+from velocity.aws.handlers.response import Response
+from velocity.aws.handlers.exceptions import AlertError
 from . import context
 
+# TODO: helpers import needs to be resolved - may need to pass table name instead
+# from some_app import helpers
 
-class LambdaHandler:
+
+class LambdaHandler(BaseHandler):
     def __init__(self, aws_event, aws_context, context_class=context.Context):
-        self.aws_event = aws_event
-        self.aws_context = aws_context
-        self.serve_action_default = True  # Set to False to disable OnActionDefault
-        self.skip_action = False  # Set to True to skip all actions
+        super().__init__(aws_event, aws_context, context_class)
 
+        # LambdaHandler-specific initialization
         requestContext = aws_event.get("requestContext") or {}
         identity = requestContext.get("identity") or {}
         headers = aws_event.get("headers") or {}
@@ -48,36 +47,6 @@ class LambdaHandler:
         else:
             self.session["device_type"] = "unknown"
 
-        self.ContextClass = context_class
-
-    def log(self, tx, message, function=None):
-        if not function:
-            function = "<Unknown>"
-            idx = 0
-            while True:
-                try:
-                    temp = sys._getframe(idx).f_code.co_name
-                except ValueError as e:
-                    break
-                if temp in ["x", "log", "_transaction"]:
-                    idx += 1
-                    continue
-                function = temp
-                break
-
-        data = {
-            "app_name": os.environ["ProjectName"],
-            "source_ip": self.session["source_ip"],
-            "referer": self.session["referer"],
-            "user_agent": self.session["user_agent"],
-            "device_type": self.session["device_type"],
-            "function": function,
-            "message": message,
-        }
-        if "email_address" in self.session:
-            data["sys_modified_by"] = self.session["email_address"]
-        tx.table("sys_log").insert(data)
-
     def serve(self, tx):
         response = Response()
         body = self.aws_event.get("body")
@@ -104,45 +73,11 @@ class LambdaHandler:
             postdata=postdata,
             response=response,
             session=self.session,
-            log=lambda message, function=None: self.log(message, function),
+            log=lambda message, function=None: self.log(tx, message, function),
         )
-        try:
-            if hasattr(self, "beforeAction"):
-                self.beforeAction(local_context)
-            actions = []
-            action = postdata.get("action", req_params.get("action"))
-            if action:
-                actions.append(
-                    f"on action {action.replace('-', ' ').replace('_', ' ')}".title().replace(
-                        " ", ""
-                    )
-                )
-            if self.serve_action_default:
-                actions.append("OnActionDefault")
-            for action in actions:
-                if self.skip_action:
-                    break
-                if hasattr(self, action):
-                    result = getattr(self, action)(local_context)
-                    if result is not None:
-                        raise Exception(
-                            f"Deprecated Feature Error: Action {action} returned a response but this is not allowed. Use Repsonse object instead: {type(result)}"
-                        )
-                    break
-            if hasattr(self, "afterAction"):
-                self.afterAction(local_context)
-        except AlertError as e:
-            response.alert(e.get_payload())
-        except Exception as e:
-            response.exception()
-            if hasattr(self, "onError"):
-                self.onError(
-                    local_context,
-                    exc=e.__class__.__name__,
-                    tb=traceback.format_exc(),
-                )
 
-        return response.render()
+        # Use BaseHandler's execute_actions method
+        return self.execute_actions(tx, local_context, postdata, req_params)
 
     def track(self, tx, data={}, user=None):
         data = data.copy()