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

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,22 @@ class SqsHandler:
             response=None,
             session=None,
         )
-        
+
+        # Use BaseHandler's execute_actions method
         try:
-            self._execute_actions(local_context)
+            self.execute_actions(tx, local_context, postdata, attrs)
         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(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/db/__init__.py

@@ -15,5 +15,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
 

velocity/db/core/engine.py

@@ -1,7 +1,5 @@
 import inspect
-import sys
 import re
-import traceback
 from functools import wraps
 from velocity.db import exceptions
 from velocity.db.core.transaction import Transaction
@@ -176,18 +174,18 @@ class Engine:
                 while True:
                     try:
                         return function(*args, **kwds)
-                    except exceptions.DbRetryTransaction as e:
+                    except exceptions.DbRetryTransaction:
                         retry_count += 1
                         if retry_count > self.MAX_RETRIES:
                             raise
                         _tx.rollback()
-                    except exceptions.DbLockTimeoutError as e:
+                    except exceptions.DbLockTimeoutError:
                         lock_timeout_count += 1
                         if lock_timeout_count > self.MAX_RETRIES:
                             raise
                         _tx.rollback()
                         continue
-                    except:
+                    except Exception:
                         raise
         finally:
             setattr(_tx, "_exec_function_depth", depth)
@@ -330,30 +328,32 @@ class Engine:
         Central method to parse driver exceptions and re-raise them as our custom exceptions.
         """
         logger = logging.getLogger(__name__)
-        
+
         # If it's already a velocity exception, just re-raise it
         if isinstance(exception, exceptions.DbException):
             raise exception
-        
+
         # Get error code and message from the SQL driver
         try:
             error_code, error_message = self.sql.get_error(exception)
         except Exception:
             error_code, error_message = None, str(exception)
-        
+
         msg = str(exception).strip().lower()
-        
+
         # Create enhanced error message with SQL query
         enhanced_message = str(exception)
         if sql:
-            enhanced_message += f"\n\nSQL Query:\n{self._format_sql_with_params(sql, parameters)}"
-        
+            enhanced_message += (
+                f"\n\nSQL Query:\n{self._format_sql_with_params(sql, parameters)}"
+            )
+
         logger.warning(
             "Database error caught. Attempting to transform: code=%s message=%s",
             error_code,
             error_message,
         )
-        
+
         # Direct error code mapping
         if error_code in self.sql.ApplicationErrorCodes:
             raise exceptions.DbApplicationError(enhanced_message) from exception
@@ -379,7 +379,7 @@ class Engine:
             raise exceptions.DbLockTimeoutError(enhanced_message) from exception
         if error_code in self.sql.RetryTransactionCodes:
             raise exceptions.DbRetryTransaction(enhanced_message) from exception
-            
+
         # Regex-based fallback patterns
         if re.search(r"key \(sys_id\)=\(\d+\) already exists.", msg, re.M):
             raise exceptions.DbDuplicateKeyError(enhanced_message) from exception
@@ -405,7 +405,7 @@ class Engine:
             raise exceptions.DbConnectionError(enhanced_message) from exception
         if "no such table:" in msg:
             raise exceptions.DbTableMissingError(enhanced_message) from exception
-        
+
         logger.error(
             "Unhandled/Unknown Error in engine.process_error",
             exc_info=True,
@@ -416,7 +416,7 @@ class Engine:
                 "sql_params": parameters,
             },
         )
-        
+
         # If we can't classify it, re-raise with enhanced message
         raise type(exception)(enhanced_message) from exception
 
@@ -426,10 +426,10 @@ class Engine:
         """
         if not sql:
             return "No SQL provided"
-            
+
         if not parameters:
             return sql
-            
+
         try:
             # Handle different parameter formats
             if isinstance(parameters, (list, tuple)):
@@ -437,45 +437,47 @@ class Engine:
                 formatted_params = []
                 for param in parameters:
                     if param is None:
-                        formatted_params.append('NULL')
+                        formatted_params.append("NULL")
                     elif isinstance(param, str):
                         # Escape single quotes and wrap in quotes
                         escaped = param.replace("'", "''")
                         formatted_params.append(f"'{escaped}'")
                     elif isinstance(param, bool):
-                        formatted_params.append('TRUE' if param else 'FALSE')
+                        formatted_params.append("TRUE" if param else "FALSE")
                     else:
                         formatted_params.append(str(param))
-                
+
                 # Replace %s placeholders with actual values
                 formatted_sql = sql
                 for param in formatted_params:
-                    formatted_sql = formatted_sql.replace('%s', param, 1)
-                    
+                    formatted_sql = formatted_sql.replace("%s", param, 1)
+
                 return formatted_sql
-                
+
             elif isinstance(parameters, dict):
                 # Handle named parameters
                 formatted_sql = sql
                 for key, value in parameters.items():
                     if value is None:
-                        replacement = 'NULL'
+                        replacement = "NULL"
                     elif isinstance(value, str):
                         escaped = value.replace("'", "''")
                         replacement = f"'{escaped}'"
                     elif isinstance(value, bool):
-                        replacement = 'TRUE' if value else 'FALSE'
+                        replacement = "TRUE" if value else "FALSE"
                     else:
                         replacement = str(value)
-                    
+
                     # Replace %(key)s or :key patterns
-                    formatted_sql = formatted_sql.replace(f'%({key})s', replacement)
-                    formatted_sql = formatted_sql.replace(f':{key}', replacement)
-                    
+                    formatted_sql = formatted_sql.replace(f"%({key})s", replacement)
+                    formatted_sql = formatted_sql.replace(f":{key}", replacement)
+
                 return formatted_sql
             else:
                 return f"{sql}\n-- Parameters: {parameters}"
-                
+
         except Exception as e:
             # If formatting fails, return original SQL with parameters shown separately
-            return f"{sql}\n-- Parameters (formatting failed): {parameters}\n-- Error: {e}"
+            return (
+                f"{sql}\n-- Parameters (formatting failed): {parameters}\n-- Error: {e}"
+            )

velocity/db/core/exceptions.py

@@ -56,15 +56,18 @@ class DuplicateRowsFoundError(Exception):
 
 class DbQueryError(DbException):
     """Database query error"""
+
     pass
 
 
 class DbTransactionError(DbException):
     """Database transaction error"""
+
     pass
 
 
 # Add aliases for backward compatibility with engine.py
 class DatabaseError(DbException):
     """Generic database error - alias for DbException"""
+
     pass

velocity/db/core/result.py

@@ -1,5 +1,3 @@
-import datetime
-import decimal
 from velocity.misc.format import to_json
 
 
@@ -7,14 +5,14 @@ class Result:
     """
     Wraps a database cursor to provide various convenience transformations
     (dict, list, tuple, etc.) and helps iterate over query results.
-    
+
     Features:
     - Pre-fetches first row for immediate boolean evaluation
     - Boolean state changes as rows are consumed: bool(result) tells you if MORE rows are available
     - Supports __bool__, is_empty(), has_results() for checking remaining results
     - Efficient iteration without unnecessary fetchall() calls
     - Caches next row to maintain accurate state without redundant database calls
-    
+
     Boolean Behavior:
     - Initially: bool(result) = True if query returned any rows
     - After each row: bool(result) = True if more rows are available to fetch
@@ -29,15 +27,15 @@ class Result:
             description = getattr(cursor, "description", []) or []
             self._headers = []
             for col in description:
-                if hasattr(col, '__getitem__'):  # Tuple-like (col[0])
+                if hasattr(col, "__getitem__"):  # Tuple-like (col[0])
                     self._headers.append(col[0].lower())
-                elif hasattr(col, 'name'):  # Object with name attribute
+                elif hasattr(col, "name"):  # Object with name attribute
                     self._headers.append(col.name.lower())
                 else:
-                    self._headers.append(f'column_{len(self._headers)}')
+                    self._headers.append(f"column_{len(self._headers)}")
         except (AttributeError, TypeError, IndexError):
             self._headers = []
-            
+
         self.__as_strings = False
         self.__enumerate = False
         self.__count = -1
@@ -49,7 +47,7 @@ class Result:
         self._cached_first_row = None
         self._first_row_fetched = False
         self._exhausted = False
-        
+
         # Pre-fetch the first row to enable immediate boolean evaluation
         self._fetch_first_row()
 
@@ -60,14 +58,16 @@ class Result:
         """
         if self._first_row_fetched or not self._cursor:
             return
-            
+
         # Don't try to fetch from INSERT/UPDATE/DELETE operations
         # These operations don't return rows, only rowcount
-        if self.__sql and self.__sql.strip().upper().startswith(('INSERT', 'UPDATE', 'DELETE', 'TRUNCATE')):
+        if self.__sql and self.__sql.strip().upper().startswith(
+            ("INSERT", "UPDATE", "DELETE", "TRUNCATE")
+        ):
             self._exhausted = True
             self._first_row_fetched = True
             return
-            
+
         try:
             raw_row = self._cursor.fetchone()
             if raw_row:
@@ -109,7 +109,9 @@ class Result:
         Return True if there are more rows available to fetch.
         This is based on whether we have a cached row or the cursor isn't exhausted.
         """
-        return self._cached_first_row is not None or (not self._exhausted and self._cursor)
+        return self._cached_first_row is not None or (
+            not self._exhausted and self._cursor
+        )
 
     def __next__(self):
         """
@@ -127,7 +129,7 @@ class Result:
                 if not row:
                     self._exhausted = True
                     raise StopIteration
-                # Try to pre-fetch the next row to update our state  
+                # Try to pre-fetch the next row to update our state
                 self._try_cache_next_row()
             except Exception as e:
                 # Handle cursor errors (e.g., closed cursor)
@@ -154,7 +156,7 @@ class Result:
         """
         if not self._cursor or self._cached_first_row is not None:
             return
-            
+
         try:
             next_row = self._cursor.fetchone()
             if next_row:
@@ -214,18 +216,22 @@ class Result:
         """
         if not self.__columns and self._cursor and hasattr(self._cursor, "description"):
             for column in self._cursor.description:
-                data = {
-                    "type_name": "unknown"  # Default value
-                }
-                
+                data = {"type_name": "unknown"}  # Default value
+
                 # Try to get type information (PostgreSQL specific)
                 try:
-                    if hasattr(column, 'type_code') and self.__tx and hasattr(self.__tx, 'pg_types'):
-                        data["type_name"] = self.__tx.pg_types.get(column.type_code, "unknown")
+                    if (
+                        hasattr(column, "type_code")
+                        and self.__tx
+                        and hasattr(self.__tx, "pg_types")
+                    ):
+                        data["type_name"] = self.__tx.pg_types.get(
+                            column.type_code, "unknown"
+                        )
                 except (AttributeError, KeyError):
                     # Keep default value
                     pass
-                
+
                 # Get all other column attributes safely
                 for key in dir(column):
                     if not key.startswith("__"):
@@ -234,8 +240,8 @@ class Result:
                         except (AttributeError, TypeError):
                             # Skip attributes that can't be accessed
                             continue
-                            
-                column_name = getattr(column, 'name', f'column_{len(self.__columns)}')
+
+                column_name = getattr(column, "name", f"column_{len(self.__columns)}")
                 self.__columns[column_name] = data
         return self.__columns
 

velocity/db/core/row.py

@@ -97,7 +97,9 @@ class Row:
         except Exception as e:
             # Check if the error message indicates a missing column
             error_msg = str(e).lower()
-            if 'column' in error_msg and ('does not exist' in error_msg or 'not found' in error_msg):
+            if "column" in error_msg and (
+                "does not exist" in error_msg or "not found" in error_msg
+            ):
                 return failobj
             # Re-raise other exceptions
             raise

velocity/db/core/table.py

@@ -54,13 +54,13 @@ class Table:
         """
         try:
             self._cursor.close()
-        except:
+        except Exception:
             pass
 
     def cursor(self):
         try:
             return self._cursor
-        except:
+        except AttributeError:
             pass
         self._cursor = self.tx.cursor()
         return self._cursor
@@ -287,7 +287,8 @@ class Table:
         if use_where:
             return Row(self, where, lock=lock)
         return Row(self, result[0]["sys_id"], lock=lock)
-    one=find
+
+    one = find
 
     @return_default(None)
     def first(
@@ -886,8 +887,8 @@ class Table:
         # Return a descriptive string of differences.
         if differences:
             differences.insert(0, f"Comparing {self.name}: {pk1} vs {pk2}")
-            differences.insert(0, f"--------------------------------------")
-            differences.append(f"--------------------------------------")
+            differences.insert(0, "--------------------------------------")
+            differences.append("--------------------------------------")
             return "\n".join(differences)
         else:
             return f"{self.name} rows {pk1} and {pk2} are identical."