velocity-python 0.0.131__tar.gz → 0.0.152__tar.gz

{velocity_python-0.0.131 → velocity_python-0.0.152}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.131
+Version: 0.0.152
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT
@@ -497,7 +497,7 @@ def update_user(tx):
     # Find and update using dictionary syntax
     user = users.find(123)  # Returns a row that behaves like a dict
     user['name'] = 'Updated Name'         # Direct assignment like a dict
-    user['updated_at'] = datetime.now()   # No special methods needed
+    user['important_date'] = datetime.now()   # No special methods needed
     
     # Check if columns exist before updating
     if 'phone' in user:

{velocity_python-0.0.131 → velocity_python-0.0.152}/README.md

@@ -447,7 +447,7 @@ def update_user(tx):
     # Find and update using dictionary syntax
     user = users.find(123)  # Returns a row that behaves like a dict
     user['name'] = 'Updated Name'         # Direct assignment like a dict
-    user['updated_at'] = datetime.now()   # No special methods needed
+    user['important_date'] = datetime.now()   # No special methods needed
     
     # Check if columns exist before updating
     if 'phone' in user:

{velocity_python-0.0.131 → velocity_python-0.0.152}/pyproject.toml

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

{velocity_python-0.0.131 → velocity_python-0.0.152}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.131"
+__version__ = version = "0.0.152"
 
 from . import aws
 from . import db

{velocity_python-0.0.131 → velocity_python-0.0.152}/src/velocity/app/orders.py

@@ -115,9 +115,7 @@ class Order:
             for key, default in defaults.items():
                 if key not in target:
                     target[key] = default() if callable(default) else default
-                elif key == "updated_at":
-                    # Always update updated_at if present
-                    target[key] = default() if callable(default) else default
+
 
     def _validate(self):
         self._apply_defaults()

velocity_python-0.0.152/src/velocity/app/tests/__init__.py

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

{velocity_python-0.0.131 → velocity_python-0.0.152}/src/velocity/aws/handlers/mixins/activity_tracker.py

@@ -9,33 +9,34 @@ import copy
 import json
 import os
 import time
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional
+from abc import ABC
+from datetime import date, datetime
+from typing import Dict, Any
 
 
 class ActivityTracker(ABC):
     """
     Mixin class providing standardized activity tracking for Lambda handlers.
-    
+
     Tracks API calls to the aws_api_activity table with consistent data structure
     and automatic duration calculation.
     """
-    
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.activity_log_key = None
         self.start_time = None
         self.end_time = None
         self.activity_data = {}
-    
+
     def track_activity_start(self, tx, context):
         """Start tracking activity for the current request"""
         self.start_time = time.time()
-        
+
         # Gather common activity data
         postdata = context.postdata()
         payload = context.payload()
-        
+
         self.activity_data = {
             "action": context.action(),
             "args": json.dumps(context.args()),
@@ -45,21 +46,34 @@ class ActivityTracker(ABC):
             "user_branch": os.environ.get("USER_BRANCH", "Unknown"),
             "start_timestamp": self.start_time,
         }
-        
+
         # Add user information if available
         user_info = self._extract_user_info(payload)
         if user_info:
             self.activity_data.update(user_info)
-            
+
         # Add session information
         session_data = context.session()
         if session_data:
-            self.activity_data.update({k: v for k, v in session_data.items() 
-                                     if k not in ['cognito_user']})
-        
+            self.activity_data.update(self._sanitize_session_data(session_data))
+
+        # Ensure all values are serializable before persisting
+        self.activity_data = {
+            key: self._normalize_activity_value(value)
+            for key, value in self.activity_data.items()
+            if value is not None
+        }
+
         # Create the activity record
-        self.activity_log_key = tx.table("aws_api_activity").new(self.activity_data).pk
-        
+        try:
+            self.activity_log_key = tx.table("aws_api_activity").new(self.activity_data).pk
+        except Exception as exc:
+            context.log(
+                f"ActivityTracker.track_activity_start failed: {exc}; keys={list(self.activity_data.keys())}",
+                "ActivityTracker.track_activity_start",
+            )
+            raise
+
         return self.activity_log_key
     
     def track_activity_success(self, tx, context):
@@ -140,3 +154,28 @@ class ActivityTracker(ABC):
                 pass
                 
         return user_info
+
+    def _sanitize_session_data(self, session: Dict[str, Any]) -> Dict[str, Any]:
+        """Remove sensitive session keys and normalize value types"""
+        sanitized = {}
+
+        for key, value in session.items():
+            if key == "cognito_user":
+                continue
+
+            sanitized[key] = self._normalize_activity_value(value)
+
+        return sanitized
+
+    def _normalize_activity_value(self, value: Any) -> Any:
+        """Convert activity data values into types acceptable by psycopg2"""
+        if isinstance(value, (dict, list, tuple, set)):
+            try:
+                return json.dumps(value)
+            except (TypeError, ValueError):
+                return str(value)
+        if isinstance(value, (datetime, date)):
+            return value.isoformat()
+        if isinstance(value, (bytes, bytearray)):
+            return value.decode("utf-8", errors="ignore")
+        return value

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

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

velocity_python-0.0.152/src/velocity/aws/tests/__init__.py

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

{velocity_python-0.0.131 → velocity_python-0.0.152}/src/velocity/db/core/decorators.py

@@ -99,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)
@@ -109,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"])
@@ -121,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"])

{velocity_python-0.0.131 → velocity_python-0.0.152}/src/velocity/db/core/engine.py

@@ -1,5 +1,7 @@
 import inspect
 import re
+import os
+from contextlib import contextmanager
 from functools import wraps
 from velocity.db import exceptions
 from velocity.db.core.transaction import Transaction
@@ -17,11 +19,12 @@ class Engine:
 
     MAX_RETRIES = 100
 
-    def __init__(self, driver, config, sql, connect_timeout=5):
+    def __init__(self, driver, config, sql, connect_timeout=5, schema_locked=False):
         self.__config = config
         self.__sql = sql
         self.__driver = driver
         self.__connect_timeout = connect_timeout
+        self.__schema_locked = schema_locked
 
     def __str__(self):
         return f"[{self.sql.server}] engine({self.config})"
@@ -205,6 +208,29 @@ class Engine:
     def sql(self):
         return self.__sql
 
+    @property
+    def schema_locked(self):
+        """Returns True if schema modifications are locked."""
+        return self.__schema_locked
+
+    def lock_schema(self):
+        """Lock schema to prevent automatic modifications."""
+        self.__schema_locked = True
+
+    def unlock_schema(self):
+        """Unlock schema to allow automatic modifications."""
+        self.__schema_locked = False
+
+    @contextmanager
+    def unlocked_schema(self):
+        """Temporarily unlock schema for automatic creation."""
+        original_state = self.__schema_locked
+        self.__schema_locked = False
+        try:
+            yield self
+        finally:
+            self.__schema_locked = original_state
+
     @property
     def version(self):
         """
@@ -341,24 +367,46 @@ class Engine:
 
         msg = str(exception).strip().lower()
 
-        # Create enhanced error message with SQL query
+        # Create enhanced error message with SQL query and context
         enhanced_message = str(exception)
+        
+        # Add specific guidance for common WHERE clause errors
+        exception_str_lower = str(exception).lower()
+        if "argument of where must be type boolean" in exception_str_lower:
+            enhanced_message += (
+                "\n\n*** WHERE CLAUSE ERROR ***\n"
+                "This error typically occurs when a WHERE clause contains a bare value "
+                "instead of a proper boolean expression.\n"
+                "Common fixes:\n"
+                "  - Change WHERE 1001 to WHERE sys_id = 1001\n"
+                "  - Change WHERE {'column': value} format in dictionaries\n"
+                "  - Ensure string WHERE clauses are complete SQL expressions"
+            )
+        
         if sql:
             enhanced_message += (
                 f"\n\nSQL Query:\n{self._format_sql_with_params(sql, parameters)}"
             )
+            
+        # Add call stack context for better debugging
+        import traceback
+        stack_trace = traceback.format_stack()
+        # Get the last few frames that aren't in the error handling itself
+        relevant_frames = [frame for frame in stack_trace if 'process_error' not in frame and 'logging' not in frame][-3:]
+        if relevant_frames:
+            enhanced_message += "\n\nCall Context:\n" + "".join(relevant_frames)
 
         # Format SQL for logging
         formatted_sql_info = ""
         if sql:
             formatted_sql_info = f" sql={self._format_sql_with_params(sql, parameters)}"
 
-        logger.warning(
-            "Database error caught. Attempting to transform: code=%s message=%s%s",
-            error_code,
-            error_message,
-            formatted_sql_info,
-        )
+        # logger.warning(
+        #     "Database error caught. Attempting to transform: code=%s message=%s%s",
+        #     error_code,
+        #     error_message,
+        #     formatted_sql_info,
+        # )
 
         # Direct error code mapping
         if error_code in self.sql.ApplicationErrorCodes:

{velocity_python-0.0.131 → velocity_python-0.0.152}/src/velocity/db/core/row.py

@@ -44,7 +44,12 @@ class Row:
     def __setitem__(self, key, val):
         if key in self.pk:
             raise Exception("Cannot update a primary key.")
-        self.table.upsert({key: val}, self.pk)
+        if hasattr(self.table, "updins"):
+            self.table.updins({key: val}, pk=self.pk)
+        elif hasattr(self.table, "upsert"):
+            self.table.upsert({key: val}, pk=self.pk)
+        else:
+            self.table.update({key: val}, pk=self.pk)
 
     def __delitem__(self, key):
         if key in self.pk:
@@ -121,7 +126,12 @@ class Row:
         if kwds:
             data.update(kwds)
         if data:
-            self.table.upsert(data, self.pk)
+            if hasattr(self.table, "updins"):
+                self.table.updins(data, pk=self.pk)
+            elif hasattr(self.table, "upsert"):
+                self.table.upsert(data, pk=self.pk)
+            else:
+                self.table.update(data, pk=self.pk)
         return self
 
     def __cmp__(self, other):