velocity-python 0.0.98__tar.gz → 0.0.100__tar.gz

{velocity_python-0.0.98 → velocity_python-0.0.100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.98
+Version: 0.0.100
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <contact@example.com>
 License: MIT

{velocity_python-0.0.98 → velocity_python-0.0.100}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.98"
+version = "0.0.100"
 authors = [
   { name="Velocity Team", email="contact@example.com" },
 ]

{velocity_python-0.0.98 → velocity_python-0.0.100}/src/velocity/db/core/engine.py

@@ -325,81 +325,192 @@ class Engine:
             result = tx.execute(sql, vals)
             return [f"{x[0]}.{x[1]}" for x in result.as_tuple()]
 
-    def process_error(self, sql_stmt=None, sql_params=None):
-        """
-        Central method to parse driver exceptions and re-raise them as our custom exceptions.
-        """
-        e = sys.exc_info()[1]
-        msg = str(e).strip().lower()
-
-        if isinstance(e, exceptions.DbException):
-            raise
-
-        error_code, error_mesg = self.sql.get_error(e)
-
+    def process_error(self, exception, sql=None, parameters=None):
+        """
+        Process database errors and raise appropriate velocity exceptions.
+        Enhanced for robustness with exception chaining and comprehensive error handling.
+        
+        Args:
+            exception: The original exception from the database driver
+            sql: The SQL statement that caused the error (optional)
+            parameters: The parameters passed to the SQL statement (optional)
+            
+        Returns:
+            The appropriate velocity exception to raise
+        """
+        logger = logging.getLogger(__name__)
+        
+        # Enhanced logging with context
+        extra_data = {
+            'exception_type': type(exception).__name__,
+            'sql': sql,
+            'parameters': parameters
+        }
+        
+        logger.error(
+            f"Database error caught. Attempting to transform: "
+            f"type={type(exception).__name__}, sql={sql[:100] if sql else 'None'}...",
+            extra=extra_data
+        )
+        
+        # Safely get error code and message with fallbacks
+        try:
+            error_code = getattr(exception, 'pgcode', None) or self.get_error(exception)
+        except Exception as e:
+            logger.warning(f"Failed to extract error code: {e}")
+            error_code = None
+            
+        try:
+            error_message = str(exception)
+        except Exception as e:
+            logger.warning(f"Failed to convert exception to string: {e}")
+            error_message = f"<Error converting exception: {type(exception).__name__}>"
+        
+        # Primary error classification by error code
+        if error_code and hasattr(self, 'error_codes'):
+            for error_class, codes in self.error_codes.items():
+                if error_code in codes:
+                    logger.info(f"Classified error by code: {error_code} -> {error_class}")
+                    try:
+                        return self._create_exception_with_chaining(
+                            error_class, error_message, exception, sql, parameters
+                        )
+                    except Exception as creation_error:
+                        logger.error(f"Failed to create {error_class} exception: {creation_error}")
+                        # Fall through to regex classification
+                        break
+        
+        # Secondary error classification by message patterns (regex fallback)
+        error_message_lower = error_message.lower()
+        
+        # Enhanced connection error patterns
+        connection_patterns = [
+            r'connection.*refused|could not connect',
+            r'network.*unreachable|network.*down',
+            r'broken pipe|connection.*broken',
+            r'timeout.*connection|connection.*timeout',
+            r'server.*closed.*connection|connection.*lost',
+            r'no route to host|host.*unreachable',
+            r'connection.*reset|reset.*connection'
+        ]
+        
+        # Enhanced duplicate key patterns  
+        duplicate_patterns = [
+            r'duplicate.*key.*value|unique.*constraint.*violated',
+            r'duplicate.*entry|key.*already.*exists',
+            r'violates.*unique.*constraint',
+            r'unique.*violation|constraint.*unique'
+        ]
+        
+        # Enhanced permission/authorization patterns
+        permission_patterns = [
+            r'permission.*denied|access.*denied|authorization.*failed',
+            r'insufficient.*privileges|privilege.*denied',
+            r'not.*authorized|unauthorized.*access',
+            r'authentication.*failed|login.*failed'
+        ]
+        
+        # Enhanced database/table not found patterns
+        not_found_patterns = [
+            r'database.*does.*not.*exist|unknown.*database',
+            r'table.*does.*not.*exist|relation.*does.*not.*exist',
+            r'no.*such.*database|database.*not.*found',
+            r'schema.*does.*not.*exist|unknown.*table'
+        ]
+        
+        # Enhanced syntax error patterns
+        syntax_patterns = [
+            r'syntax.*error|invalid.*syntax',
+            r'malformed.*query|bad.*sql.*grammar',
+            r'unexpected.*token|parse.*error'
+        ]
+        
+        # Enhanced deadlock/timeout patterns
+        deadlock_patterns = [
+            r'deadlock.*detected|lock.*timeout',
+            r'timeout.*waiting.*for.*lock|query.*timeout',
+            r'lock.*wait.*timeout|deadlock.*found'
+        ]
+        
+        # Comprehensive pattern matching with error class mapping
+        pattern_mappings = [
+            (connection_patterns, 'ConnectionError'),
+            (duplicate_patterns, 'DuplicateError'), 
+            (permission_patterns, 'PermissionError'),
+            (not_found_patterns, 'NotFoundError'),
+            (syntax_patterns, 'SyntaxError'),
+            (deadlock_patterns, 'DeadlockError')
+        ]
+        
+        # Apply pattern matching
+        for patterns, error_class in pattern_mappings:
+            for pattern in patterns:
+                try:
+                    if re.search(pattern, error_message_lower):
+                        logger.info(f"Classified error by pattern: '{pattern}' -> {error_class}")
+                        return self._create_exception_with_chaining(
+                            error_class, error_message, exception, sql, parameters
+                        )
+                except re.error as regex_error:
+                    logger.warning(f"Regex pattern error '{pattern}': {regex_error}")
+                    continue
+                except Exception as pattern_error:
+                    logger.error(f"Error applying pattern '{pattern}': {pattern_error}")
+                    continue
+        
+        # Fallback: return generic database error with full context
         logger.warning(
-            "Database error caught. Attempting to transform: code=%s message=%s",
-            error_code,
-            error_mesg,
+            f"Could not classify error. Returning generic DatabaseError. "
+            f"Error code: {error_code}, Available error codes: {list(getattr(self, 'error_codes', {}).keys()) if hasattr(self, 'error_codes') else 'None'}"
         )
-
-        if error_code in self.sql.ApplicationErrorCodes:
-            raise exceptions.DbApplicationError from None
-        if error_code in self.sql.ColumnMissingErrorCodes:
-            raise exceptions.DbColumnMissingError from None
-        if error_code in self.sql.TableMissingErrorCodes:
-            raise exceptions.DbTableMissingError from None
-        if error_code in self.sql.DatabaseMissingErrorCodes:
-            raise exceptions.DbDatabaseMissingError from None
-        if error_code in self.sql.ForeignKeyMissingErrorCodes:
-            raise exceptions.DbForeignKeyMissingError from None
-        if error_code in self.sql.TruncationErrorCodes:
-            raise exceptions.DbTruncationError from None
-        if error_code in self.sql.DataIntegrityErrorCodes:
-            raise exceptions.DbDataIntegrityError from None
-        if error_code in self.sql.ConnectionErrorCodes:
-            raise exceptions.DbConnectionError from None
-        if error_code in self.sql.DuplicateKeyErrorCodes:
-            raise exceptions.DbDuplicateKeyError from None
-        if re.search(r"key \(sys_id\)=\(\d+\) already exists.", msg, re.M):
-            raise exceptions.DbDuplicateKeyError from None
-        if error_code in self.sql.DatabaseObjectExistsErrorCodes:
-            raise exceptions.DbObjectExistsError from None
-        if error_code in self.sql.LockTimeoutErrorCodes:
-            raise exceptions.DbLockTimeoutError from None
-        if error_code in self.sql.RetryTransactionCodes:
-            raise exceptions.DbRetryTransaction from None
-        if re.findall(r"database.*does not exist", msg, re.M):
-            raise exceptions.DbDatabaseMissingError from None
-        if re.findall(r"no such database", msg, re.M):
-            raise exceptions.DbDatabaseMissingError from None
-        if re.findall(r"already exists", msg, re.M):
-            raise exceptions.DbObjectExistsError from None
-        if re.findall(r"server closed the connection unexpectedly", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"no connection to the server", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"connection timed out", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"could not connect to server", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"cannot connect to server", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"connection already closed", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if re.findall(r"cursor already closed", msg, re.M):
-            raise exceptions.DbConnectionError from None
-        if "no such table:" in msg:
-            raise exceptions.DbTableMissingError from None
-
-        logger.error(
-            "Unhandled/Unknown Error in engine.process_error",
-            exc_info=True,
-            extra={
-                "error_code": error_code,
-                "error_msg": error_mesg,
-                "sql_stmt": sql_stmt,
-                "sql_params": sql_params,
-            },
+        
+        return self._create_exception_with_chaining(
+            'DatabaseError', error_message, exception, sql, parameters
         )
-        raise
+    
+    def _create_exception_with_chaining(self, error_class, message, original_exception, sql=None, parameters=None):
+        """
+        Create a velocity exception with proper exception chaining.
+        
+        Args:
+            error_class: The name of the exception class to create
+            message: The error message
+            original_exception: The original exception to chain
+            sql: The SQL statement (optional)
+            parameters: The SQL parameters (optional)
+            
+        Returns:
+            The created exception with proper chaining
+        """
+        logger = logging.getLogger(__name__)
+        
+        try:
+            # Import the exception class dynamically
+            exception_module = __import__('velocity.db.exceptions', fromlist=[error_class])
+            ExceptionClass = getattr(exception_module, error_class)
+            
+            # Create enhanced message with context
+            if sql:
+                enhanced_message = f"{message} (SQL: {sql[:200]}{'...' if len(sql) > 200 else ''})"
+            else:
+                enhanced_message = message
+                
+            # Create the exception with chaining
+            new_exception = ExceptionClass(enhanced_message)
+            new_exception.__cause__ = original_exception  # Preserve exception chain
+            
+            return new_exception
+            
+        except (ImportError, AttributeError) as e:
+            logger.error(f"Could not import exception class {error_class}: {e}")
+            # Fallback to generic database error
+            try:
+                exception_module = __import__('velocity.db.exceptions', fromlist=['DatabaseError'])
+                DatabaseError = getattr(exception_module, 'DatabaseError')
+                fallback_exception = DatabaseError(f"Database error: {message}")
+                fallback_exception.__cause__ = original_exception
+                return fallback_exception
+            except Exception as fallback_error:
+                logger.critical(f"Failed to create fallback exception: {fallback_error}")
+                # Last resort: return the original exception
+                return original_exception

{velocity_python-0.0.98 → velocity_python-0.0.100}/src/velocity/db/servers/postgres/sql.py

@@ -68,20 +68,20 @@ class SQL:
 
     default_schema = "public"
 
-    ApplicationErrorCodes = ["22P02", "42883"]
+    ApplicationErrorCodes = ["22P02", "42883", "42501", "42601", "25P01", "25P02"]
 
-    DatabaseMissingErrorCodes = []
+    DatabaseMissingErrorCodes = ["3D000"]
     TableMissingErrorCodes = ["42P01"]
     ColumnMissingErrorCodes = ["42703"]
     ForeignKeyMissingErrorCodes = ["42704"]
 
-    ConnectionErrorCodes = ["08001", "08S01", "57P03", "08006", "53300"]
-    DuplicateKeyErrorCodes = []  # Handled in regex check.
-    RetryTransactionCodes = []
+    ConnectionErrorCodes = ["08001", "08S01", "57P03", "08006", "53300", "08003", "08004", "08P01"]
+    DuplicateKeyErrorCodes = ["23505"]  # unique_violation - no longer relying only on regex
+    RetryTransactionCodes = ["40001", "40P01", "40002"]
     TruncationErrorCodes = ["22001"]
     LockTimeoutErrorCodes = ["55P03"]
     DatabaseObjectExistsErrorCodes = ["42710", "42P07", "42P04"]
-    DataIntegrityErrorCodes = ["23503"]
+    DataIntegrityErrorCodes = ["23503", "23502", "23514", "23P01", "22003"]
 
     @classmethod
     def get_error(self, e):

{velocity_python-0.0.98 → velocity_python-0.0.100}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.98
+Version: 0.0.100
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <contact@example.com>
 License: MIT

{velocity_python-0.0.98 → velocity_python-0.0.100}/src/velocity_python.egg-info/SOURCES.txt

@@ -57,10 +57,12 @@ src/velocity_python.egg-info/requires.txt
 src/velocity_python.egg-info/top_level.txt
 tests/test_db.py
 tests/test_email_processing.py
+tests/test_fix.py
 tests/test_format.py
 tests/test_iconv.py
 tests/test_merge.py
 tests/test_oconv.py
+tests/test_original_error.py
 tests/test_postgres.py
 tests/test_response.py
 tests/test_spreadsheet_functions.py

velocity_python-0.0.100/tests/test_fix.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+
+# Test script to verify the duplicate_rows fix
+
+def test_grouping_fix():
+    """Test the fixed grouping logic"""
+    
+    # Simulate duplicate rows that would come from duplicate_rows()
+    duplicate_rows = [
+        {"sys_id": 1, "email_address": "test1@example.com", "card_number": "1234", "expiration_date": "2024-01", "status": None},
+        {"sys_id": 2, "email_address": "test1@example.com", "card_number": "1234", "expiration_date": "2024-02", "status": None},
+        {"sys_id": 3, "email_address": "test2@example.com", "card_number": "5678", "expiration_date": "2024-03", "status": None},
+        {"sys_id": 4, "email_address": "test2@example.com", "card_number": "5678", "expiration_date": "2024-01", "status": None},
+    ]
+    
+    # Group rows by email_address and card_number (the fixed logic)
+    groups = {}
+    for row in duplicate_rows:
+        key = (row["email_address"], row["card_number"])
+        if key not in groups:
+            groups[key] = []
+        groups[key].append(row)
+    
+    print("Groups found:")
+    for key, group in groups.items():
+        print(f"  Key: {key}, Group size: {len(group)}")
+        
+        # Test the sorting that was causing the original error
+        try:
+            sorted_group = sorted(group, key=lambda x: x["expiration_date"])
+            print(f"    Sorted by expiration_date: {[row['expiration_date'] for row in sorted_group]}")
+            
+            # Test the enumeration that happens in the original code
+            for idx, row in enumerate(sorted_group):
+                print(f"    {idx}: {row['sys_id']}, {row['email_address']}, {row['card_number']}, {row['expiration_date']}")
+                
+        except TypeError as e:
+            print(f"    ERROR: {e}")
+            return False
+    
+    return True
+
+if __name__ == "__main__":
+    success = test_grouping_fix()
+    if success:
+        print("\n✓ Fix appears to work correctly!")
+    else:
+        print("\n✗ Fix has issues")

velocity_python-0.0.100/tests/test_original_error.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+
+# Test script to demonstrate the original error
+
+def test_original_error():
+    """Demonstrate the original error that was happening"""
+    
+    # Simulate what duplicate_rows() was returning (individual dicts, not groups)
+    # The code was expecting groups but getting individual rows
+    fake_groups = [
+        {"sys_id": 1, "email_address": "test1@example.com", "card_number": "1234", "expiration_date": "2024-01", "status": None},
+        {"sys_id": 2, "email_address": "test1@example.com", "card_number": "1234", "expiration_date": "2024-02", "status": None},
+    ]
+    
+    print("Testing original problematic code pattern:")
+    
+    for group in fake_groups:  # group is actually a single row/dict
+        print(f"Processing 'group': {group}")
+        try:
+            # This is the line that was failing: sorted(group, key=lambda x: x["expiration_date"])
+            # When group is a dict, sorted() iterates over the keys (strings), not the values
+            sorted_group = sorted(group, key=lambda x: x["expiration_date"])
+            print(f"  Sorted result: {sorted_group}")
+        except TypeError as e:
+            print(f"  ERROR: {e}")
+            print(f"  This happened because 'group' is a dict, so sorted() iterates over keys: {list(group.keys())}")
+            print(f"  The lambda tries to access x['expiration_date'] where x is a string key, not a dict")
+            return False
+    
+    return True
+
+if __name__ == "__main__":
+    print("Demonstrating the original error:")
+    test_original_error()