velocity-python 0.0.109__py3-none-any.whl → 0.0.155__py3-none-any.whl

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
 

velocity/aws/handlers/sqs_handler.py

@@ -6,109 +6,59 @@ It includes logging capabilities, action routing, and error handling.
 """
 
 import json
-import os
-import sys
-import traceback
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
-from velocity.aws import DEBUG
 from velocity.aws.handlers import context as VelocityContext
-from velocity.misc.format import to_json
+from velocity.aws.handlers.base_handler import BaseHandler
 
 
-class SqsHandler:
+class SqsHandler(BaseHandler):
     """
     Base class for handling SQS events in AWS Lambda functions.
-    
+
     Provides structured processing of SQS records with automatic action routing,
     logging capabilities, and error handling hooks.
     """
 
-    def __init__(self, aws_event: Dict[str, Any], aws_context: Any, 
-                 context_class=VelocityContext.Context):
+    def __init__(
+        self,
+        aws_event: Dict[str, Any],
+        aws_context: Any,
+        context_class=VelocityContext.Context,
+    ):
         """
         Initialize the SQS handler.
-        
+
         Args:
             aws_event: The AWS Lambda event containing SQS records
             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
-        self.skip_action = False
-        self.ContextClass = context_class
-
-    def log(self, tx, message: str, function: Optional[str] = None):
-        """
-        Log a message to the system log table.
-        
-        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()
-
-        data = {
-            "app_name": os.environ.get("ProjectName", "Unknown"),
-            "referer": "SQS",
-            "user_agent": "QueueHandler",
-            "device_type": "Lambda",
-            "function": function,
-            "message": message,
-            "sys_modified_by": "Lambda:BackOfficeQueueHandler",
-        }
-        tx.table("sys_log").insert(data)
-    
-    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>"
+        super().__init__(aws_event, aws_context, context_class)
 
     def serve(self, tx):
         """
         Process all SQS records in the event.
-        
+
         Args:
             tx: Database transaction object
         """
         records = self.aws_event.get("Records", [])
-        
+
         for record in records:
             self._process_record(tx, record)
-    
+
     def _process_record(self, tx, record: Dict[str, Any]):
         """
         Process a single SQS record.
-        
+
         Args:
             tx: Database transaction object
             record: Individual SQS record to process
         """
         attrs = record.get("attributes", {})
         postdata = {}
-        
+
         # Parse message body if present
         body = record.get("body")
         if body:
@@ -127,93 +77,28 @@ class SqsHandler:
             response=None,
             session=None,
         )
+
+        # Determine action from postdata
+        action = postdata.get("action") if isinstance(postdata, dict) else None
         
+        # Get the list of actions to execute
+        actions = self.get_actions_to_execute(action)
+
+        # Use BaseHandler's execute_actions method
         try:
-            self._execute_actions(local_context)
+            self.execute_actions(tx, local_context, actions)
         except Exception as e:
-            if hasattr(self, "onError"):
-                self.onError(
-                    local_context,
-                    exc=e.__class__.__name__,
-                    tb=traceback.format_exc(),
-                )
-            else:
-                # Re-raise if no error handler is defined
-                raise
-    
-    def _execute_actions(self, local_context):
-        """
-        Execute the appropriate actions for the given context.
-        
-        Args:
-            local_context: The context object for this record
-        """
-        # Execute beforeAction hook if available
-        if hasattr(self, "beforeAction"):
-            self.beforeAction(local_context)
-        
-        # Determine which actions to execute
-        actions = self._get_actions_to_execute(local_context)
-        
-        # Execute the first matching action
-        for action in actions:
-            if self.skip_action:
-                return
-                
-            if hasattr(self, action):
-                getattr(self, action)(local_context)
-                break
-        
-        # Execute afterAction hook if available
-        if hasattr(self, "afterAction"):
-            self.afterAction(local_context)
-    
-    def _get_actions_to_execute(self, local_context) -> list:
-        """
-        Get the list of actions to execute for the given context.
-        
-        Args:
-            local_context: The context object for this record
-            
-        Returns:
-            List of action method names to try executing
-        """
-        actions = []
-        
-        # Add specific action if available
-        action = local_context.action()
-        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 _format_action_name(self, action: str) -> str:
-        """
-        Format an action string into a method name.
-        
-        Args:
-            action: The raw action string
-            
-        Returns:
-            Formatted method name
-        """
-        formatted = action.replace('-', ' ').replace('_', ' ')
-        return f"on action {formatted}".title().replace(" ", "")
+            self.handle_error(tx, local_context, e)
 
     def OnActionDefault(self, tx, context):
         """
         Default action handler when no specific action is found.
-        
+
         Args:
             tx: Database transaction object
             context: The context object for this record
         """
-        action = context.action() if hasattr(context, 'action') else 'unknown'
+        action = context.action() if hasattr(context, "action") else "unknown"
         warning_message = (
             f"[Warn] Action handler not found. Calling default action "
             f"`SqsHandler.OnActionDefault` with the following parameters:\n"

velocity/aws/tests/__init__.py

@@ -0,0 +1 @@
+# AWS module tests

velocity/aws/tests/test_lambda_handler_json_serialization.py

@@ -0,0 +1,120 @@
+"""
+Test Lambda Handler JSON Serialization Fix
+
+This test verifies that LambdaHandler.serve() returns a JSON-serializable
+dictionary instead of a Response object, preventing the 
+"Object of type method is not JSON serializable" error.
+"""
+
+import json
+import unittest
+from unittest.mock import MagicMock, patch
+import sys
+import os
+
+# Add src to path for testing
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from velocity.aws.handlers.lambda_handler import LambdaHandler
+from velocity.aws.handlers.response import Response
+
+
+class TestLambdaHandlerJSONSerialization(unittest.TestCase):
+    """Test cases for Lambda Handler JSON serialization."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.test_event = {
+            "body": '{"action": "test", "payload": {}}',
+            "httpMethod": "POST",
+            "headers": {"Content-Type": "application/json"},
+            "requestContext": {
+                "identity": {
+                    "sourceIp": "127.0.0.1",  # localhost test IP for unit testing
+                    "userAgent": "test-agent"
+                }
+            },
+            "queryStringParameters": {}
+        }
+        
+        self.test_context = MagicMock()
+        self.test_context.function_name = "test-function"
+
+    def test_serve_returns_json_serializable_dict(self):
+        """Test that serve() returns a JSON-serializable dictionary."""
+        
+        # Create handler
+        handler = LambdaHandler(self.test_event, self.test_context)
+        
+        # Mock the transaction decorator to pass through tx
+        with patch('velocity.aws.handlers.lambda_handler.engine') as mock_engine:
+            def mock_transaction(func):
+                def wrapper(*args, **kwargs):
+                    mock_tx = MagicMock()
+                    return func(mock_tx, *args, **kwargs)
+                return wrapper
+            
+            mock_engine.transaction = mock_transaction
+            
+            # Call serve method
+            result = handler.serve(MagicMock())
+            
+            # Verify result is a dictionary (JSON-serializable)
+            self.assertIsInstance(result, dict)
+            
+            # Verify it has the expected Lambda response structure
+            self.assertIn("statusCode", result)
+            self.assertIn("headers", result)
+            self.assertIn("body", result)
+            
+            # Verify the body is a JSON string
+            self.assertIsInstance(result["body"], str)
+            
+            # Verify the entire result can be JSON serialized
+            try:
+                json.dumps(result)
+            except (TypeError, ValueError) as e:
+                self.fail(f"Result is not JSON serializable: {e}")
+
+    def test_response_object_has_render_method(self):
+        """Test that Response object has a proper render method."""
+        response = Response()
+        
+        # Verify render method exists
+        self.assertTrue(hasattr(response, 'render'))
+        self.assertTrue(callable(response.render))
+        
+        # Verify render returns a dictionary
+        rendered = response.render()
+        self.assertIsInstance(rendered, dict)
+        
+        # Verify structure
+        self.assertIn("statusCode", rendered)
+        self.assertIn("headers", rendered)
+        self.assertIn("body", rendered)
+        
+        # Verify JSON serializable
+        try:
+            json.dumps(rendered)
+        except (TypeError, ValueError) as e:
+            self.fail(f"Rendered response is not JSON serializable: {e}")
+
+    def test_response_render_vs_raw_object(self):
+        """Test the difference between Response object and rendered response."""
+        response = Response()
+        
+        # Raw response object should not be directly JSON serializable
+        # (it contains method references)
+        with self.assertRaises((TypeError, ValueError)):
+            json.dumps(response)
+        
+        # But rendered response should be JSON serializable
+        rendered = response.render()
+        try:
+            json.dumps(rendered)
+        except (TypeError, ValueError) as e:
+            self.fail(f"Rendered response should be JSON serializable: {e}")
+
+
+if __name__ == '__main__':
+    unittest.main()

velocity/aws/tests/test_response.py

@@ -0,0 +1,163 @@
+import unittest
+import sys
+from unittest.mock import patch, MagicMock
+
+# Mock the support module before importing the module that depends on it
+sys.modules["support"] = MagicMock()
+sys.modules["support.app"] = MagicMock()
+sys.modules["support.app"].DEBUG = True
+
+from velocity.aws.handlers.response import Response  # Replace with actual module path
+
+
+class TestResponse(unittest.TestCase):
+
+    def setUp(self):
+        self.response = Response()
+
+    def test_initial_status_code(self):
+        self.assertEqual(self.response.status(), 200)
+
+    def test_set_status_code(self):
+        self.response.set_status(404)
+        self.assertEqual(self.response.status(), 404)
+
+    def test_initial_headers(self):
+        headers = self.response.headers()
+        self.assertIn("Content-Type", headers)
+        self.assertEqual(headers["Content-Type"], "application/json")
+
+    def test_set_headers(self):
+        custom_headers = {"x-custom-header": "value"}
+        self.response.set_headers(custom_headers)
+        headers = self.response.headers()
+        self.assertEqual(headers["X-Custom-Header"], "value")  # Ensures capitalization
+        self.assertIn("Content-Type", headers)
+
+    def test_alert_action(self):
+        self.response.alert("Test message", "Alert Title")
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "alert")
+        self.assertEqual(self.response.actions[0]["payload"]["title"], "Alert Title")
+        self.assertEqual(self.response.actions[0]["payload"]["message"], "Test message")
+
+    def test_toast_action_valid_variant(self):
+        self.response.toast("Toast message", "warning")
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "toast")
+        self.assertEqual(
+            self.response.actions[0]["payload"]["options"]["variant"], "warning"
+        )
+
+    def test_toast_action_invalid_variant(self):
+        with self.assertRaises(ValueError) as context:
+            self.response.toast("Invalid toast", "invalid_variant")
+        self.assertIn(
+            "Notistack variant 'invalid_variant' not in", str(context.exception)
+        )
+
+    def test_load_object_action(self):
+        payload = {"key": "value"}
+        self.response.load_object(payload)
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "load-object")
+        self.assertEqual(self.response.actions[0]["payload"], payload)
+
+    def test_update_store_action(self):
+        payload = {"key": "value"}
+        self.response.update_store(payload)
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "update-store")
+        self.assertEqual(self.response.actions[0]["payload"], payload)
+
+    def test_file_download_action(self):
+        payload = {"file": "file.txt"}
+        self.response.file_download(payload)
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "file-download")
+        self.assertEqual(self.response.actions[0]["payload"], payload)
+
+    def test_redirect_action(self):
+        self.response.redirect("https://example.com")
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "redirect")
+        self.assertEqual(
+            self.response.actions[0]["payload"]["location"], "https://example.com"
+        )
+
+    def test_signout_action(self):
+        self.response.signout()
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "signout")
+
+    def test_set_table_action(self):
+        payload = {"table": "data"}
+        self.response.set_table(payload)
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "set-table")
+        self.assertEqual(self.response.actions[0]["payload"], payload)
+
+    def test_set_repo_action(self):
+        payload = {"repo": "data"}
+        self.response.set_repo(payload)
+        self.assertEqual(len(self.response.actions), 1)
+        self.assertEqual(self.response.actions[0]["action"], "set-repo")
+        self.assertEqual(self.response.actions[0]["payload"], payload)
+
+    def test_exception_handling_debug_on(self):
+        with patch("your_module.DEBUG", True), patch(
+            "traceback.format_exc", return_value="formatted traceback"
+        ):
+            try:
+                raise ValueError("Test exception")
+            except ValueError:
+                self.response.exception()
+
+        self.assertEqual(self.response.status(), 500)
+        exception_info = self.response.body["python_exception"]
+        self.assertEqual(exception_info["value"], "Test exception")
+        self.assertEqual(exception_info["traceback"], "formatted traceback")
+
+    def test_exception_handling_debug_off(self):
+        with patch("your_module.DEBUG", False), patch(
+            "traceback.format_exc", return_value="formatted traceback"
+        ):
+            try:
+                raise ValueError("Test exception")
+            except ValueError:
+                self.response.exception()
+
+        self.assertEqual(self.response.status(), 500)
+        exception_info = self.response.body["python_exception"]
+        self.assertEqual(exception_info["value"], "Test exception")
+        self.assertIsNone(exception_info["traceback"])
+
+    def test_chaining_methods(self):
+        response = (
+            self.response.set_status(201)
+            .alert("Chain Alert")
+            .toast("Chain Toast", "info")
+            .redirect("https://chained-example.com")
+        )
+        self.assertEqual(response.status(), 201)
+        self.assertEqual(len(response.actions), 3)
+        self.assertEqual(
+            response.actions[2]["payload"]["location"], "https://chained-example.com"
+        )
+
+    def test_render(self):
+        self.response.set_body({"key": "value"})
+        rendered_response = self.response.render()
+        self.assertEqual(rendered_response["statusCode"], 200)
+        self.assertEqual(
+            rendered_response["headers"]["Content-Type"], "application/json"
+        )
+        self.assertIn('"key": "value"', rendered_response["body"])
+
+    def test_format_header_key(self):
+        result = Response._format_header_key("x-custom-header")
+        self.assertEqual(result, "X-Custom-Header")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity/db/__init__.py

@@ -5,9 +5,6 @@ from velocity.db.servers import sqlite
 from velocity.db.servers import sqlserver
 from velocity.db import utils
 
-# Export exceptions at the package level for backward compatibility
-from velocity.db.exceptions import *
-
 # Export commonly used utility functions
 from velocity.db.utils import (
     safe_sort_rows,
@@ -15,5 +12,20 @@ from velocity.db.utils import (
     safe_sort_key_none_first,
     safe_sort_key_with_default,
     group_by_fields,
-    safe_sort_grouped_rows
+    safe_sort_grouped_rows,
 )
+
+__all__ = [
+    "exceptions",
+    "postgres",
+    "mysql",
+    "sqlite",
+    "sqlserver",
+    "utils",
+    "safe_sort_rows",
+    "safe_sort_key_none_last",
+    "safe_sort_key_none_first",
+    "safe_sort_key_with_default",
+    "group_by_fields",
+    "safe_sort_grouped_rows",
+]

velocity/db/core/decorators.py

@@ -1,6 +1,5 @@
 import time
 import random
-import traceback
 from functools import wraps
 from velocity.db import exceptions
 
@@ -100,7 +99,8 @@ def return_default(
 
 def create_missing(func):
     """
-    If the function call fails with DbColumnMissingError or DbTableMissingError, tries to create them and re-run.
+    If the function call fails with DbColumnMissingError or DbTableMissingError, 
+    tries to create them and re-run (only if schema is not locked).
     """
 
     @wraps(func)
@@ -110,8 +110,16 @@ def create_missing(func):
             result = func(self, *args, **kwds)
             self.tx.release_savepoint(sp, cursor=self.cursor())
             return result
-        except exceptions.DbColumnMissingError:
+        except exceptions.DbColumnMissingError as e:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())
+            
+            # Check if schema is locked
+            if self.tx.engine.schema_locked:
+                raise exceptions.DbSchemaLockedError(
+                    f"Cannot create missing column: schema is locked. Original error: {e}"
+                ) from e
+                
+            # Existing logic for automatic creation
             data = {}
             if "pk" in kwds:
                 data.update(kwds["pk"])
@@ -122,8 +130,16 @@ def create_missing(func):
                     data.update(arg)
             self.alter(data)
             return func(self, *args, **kwds)
-        except exceptions.DbTableMissingError:
+        except exceptions.DbTableMissingError as e:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())
+            
+            # Check if schema is locked
+            if self.tx.engine.schema_locked:
+                raise exceptions.DbSchemaLockedError(
+                    f"Cannot create missing table: schema is locked. Original error: {e}"
+                ) from e
+                
+            # Existing logic for automatic creation
             data = {}
             if "pk" in kwds:
                 data.update(kwds["pk"])