velocity-python 0.0.143__tar.gz → 0.0.158__tar.gz

{velocity_python-0.0.143 → velocity_python-0.0.158}/PKG-INFO

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

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

{velocity_python-0.0.143 → velocity_python-0.0.158}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.143"
+__version__ = version = "0.0.158"
 
 from . import aws
 from . import db

{velocity_python-0.0.143 → velocity_python-0.0.158}/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.158/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.143 → velocity_python-0.0.158}/src/velocity/db/core/decorators.py

@@ -4,10 +4,27 @@ from functools import wraps
 from velocity.db import exceptions
 
 
+_PRIMARY_KEY_PATTERNS = (
+    "primary key",
+    "key 'primary'",
+    'key "primary"',
+)
+
+
+def _is_primary_key_duplicate(error):
+    """Return True when the duplicate-key error is targeting the primary key."""
+
+    message = str(error or "")
+    lowered = message.lower()
+
+    if "sys_id" in lowered:
+        return True
+
+    return any(pattern in lowered for pattern in _PRIMARY_KEY_PATTERNS)
+
+
 def retry_on_dup_key(func):
-    """
-    Retries a function call if it raises DbDuplicateKeyError, up to max_retries.
-    """
+    """Retry when insert/update fails because the primary key already exists."""
 
     @wraps(func)
     def retry_decorator(self, *args, **kwds):
@@ -19,10 +36,12 @@ def retry_on_dup_key(func):
                 result = func(self, *args, **kwds)
                 self.tx.release_savepoint(sp, cursor=self.cursor())
                 return result
-            except exceptions.DbDuplicateKeyError:
+            except exceptions.DbDuplicateKeyError as error:
                 self.tx.rollback_savepoint(sp, cursor=self.cursor())
                 if "sys_id" in kwds.get("data", {}):
                     raise
+                if not _is_primary_key_duplicate(error):
+                    raise
                 retries += 1
                 if retries >= max_retries:
                     raise
@@ -34,9 +53,7 @@ def retry_on_dup_key(func):
 
 
 def reset_id_on_dup_key(func):
-    """
-    Wraps an INSERT/UPSERT to reset the sys_id sequence on duplicate key collisions.
-    """
+    """Retry sys_id sequence bump only when the primary key collides."""
 
     @wraps(func)
     def reset_decorator(self, *args, retries=0, **kwds):
@@ -45,10 +62,12 @@ def reset_id_on_dup_key(func):
             result = func(self, *args, **kwds)
             self.tx.release_savepoint(sp, cursor=self.cursor())
             return result
-        except exceptions.DbDuplicateKeyError:
+        except exceptions.DbDuplicateKeyError as error:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())
             if "sys_id" in kwds.get("data", {}):
                 raise
+            if not _is_primary_key_duplicate(error):
+                raise
             if retries < 3:
                 backoff_time = (2**retries) * 0.01 + random.uniform(0, 0.02)
                 time.sleep(backoff_time)

{velocity_python-0.0.143 → velocity_python-0.0.158}/src/velocity/db/core/engine.py

@@ -1,10 +1,10 @@
 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
+from velocity.db.utils import mask_config_for_display
 
 import logging
 
@@ -27,7 +27,8 @@ class Engine:
         self.__schema_locked = schema_locked
 
     def __str__(self):
-        return f"[{self.sql.server}] engine({self.config})"
+        safe_config = mask_config_for_display(self.config)
+        return f"[{self.sql.server}] engine({safe_config})"
 
     def connect(self):
         """

{velocity_python-0.0.143 → velocity_python-0.0.158}/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):