velocity-python 0.0.116__py3-none-any.whl → 0.0.118__py3-none-any.whl

velocity/__init__.py

@@ -1,6 +1,8 @@
-__version__ = version = "0.0.116"
+__version__ = version = "0.0.118"
 
 from . import aws
 from . import db
 from . import misc
 from . import app
+
+__all__ = ["aws", "db", "misc", "app"]

velocity/aws/__init__.py

@@ -18,3 +18,6 @@ class AWS(object):
         response = requests.get("http://169.254.169.254/latest/meta-data/instance-id")
         instance_id = response.text
         return instance_id
+
+
+__all__ = ["AmplifyProject", "AWS"]

velocity/aws/amplify.py

@@ -1,4 +1,5 @@
 import boto3
+import time
 
 
 class AmplifyProject:
@@ -325,7 +326,12 @@ class AmplifyProject:
                 "ec2:AttachNetworkInterface",
                 "ec2:DescribeNetworkInterfaces",
                 "ec2:DeleteNetworkInterface",
-                "cognito-idp:*",
+                "ec2:DescribeSecurityGroups",
+                "ec2:AuthorizeSecurityGroupIngress",
+                "ec2:AuthorizeSecurityGroupEgress",
+                "ec2:RevokeSecurityGroupIngress",
+                "ec2:RevokeSecurityGroupEgress",
+                "cognito-idp:*"
             ],
         }
     ],
@@ -389,10 +395,9 @@ class AmplifyProject:
             except Exception:
                 pass
 
-    def check_policies(
-        self,
-    ):
+    def check_policies(self, function):
         # Attach a role policy
+        iam_client = boto3.client("iam")
         response = iam_client.list_attached_role_policies(
             RoleName=function["Role"].split("/")[1]
         )
@@ -426,7 +431,7 @@ class AmplifyProject:
         print(f"\n🔧 Applying {len(env_vars)} environment variables...")
         for function_name in self.list_lambda_functions_filtered(branch):
             print(f"➡️ Updating Lambda function: {function_name}")
-            self.update_lambda_env(function_name, env_vars)
+            self.update_lambda_function(function_name, env_vars)
 
         print(
             "✅ Environment variables successfully applied to matching Lambda functions.\n"
@@ -435,7 +440,6 @@ class AmplifyProject:
 
 def main():
     app_id = "d3c209q3ri53mk"
-    branch = "demo"
     app = AmplifyProject(app_id)
     print(app.list_backend_branches())
 

velocity/aws/handlers/__init__.py

@@ -1,3 +1,5 @@
 from velocity.aws.handlers.response import Response
 from velocity.aws.handlers.lambda_handler import LambdaHandler
 from velocity.aws.handlers.sqs_handler import SqsHandler
+
+__all__ = ["Response", "LambdaHandler", "SqsHandler"]

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/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 is 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": "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/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/aws/handlers/lambda_handler.py

@@ -1,23 +1,17 @@
-from velocity.misc.format import to_json
 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 . 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 +42,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")
@@ -85,7 +49,7 @@ class LambdaHandler:
         if isinstance(body, str) and len(body) > 0:
             try:
                 postdata = json.loads(body)
-            except:
+            except (json.JSONDecodeError, TypeError):
                 postdata = {"raw_body": body}
         elif isinstance(body, dict):
             postdata = body
@@ -93,7 +57,7 @@ class LambdaHandler:
             try:
                 new = "\n".join(body)
                 postdata = json.loads(new)
-            except:
+            except (json.JSONDecodeError, TypeError):
                 postdata = {"raw_body": body}
 
         req_params = self.aws_event.get("queryStringParameters") or {}
@@ -104,45 +68,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()
@@ -155,7 +85,8 @@ class LambdaHandler:
                 "sys_modified_by": self.session["email_address"],
             }
         )
-        tx.table(helpers.get_tracking_table(user or self.session)).insert(data)
+        # TODO: Fix undefined helpers reference
+        # tx.table(helpers.get_tracking_table(user or self.session)).insert(data)
 
     def OnActionDefault(self, tx, context):
         context.response().set_body(

velocity/aws/handlers/response.py

@@ -1,6 +1,6 @@
 import sys
 import traceback
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 from velocity.misc.format import to_json
 from support.app import DEBUG