velocity-python 0.0.108__py3-none-any.whl → 0.0.110__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.108"
+__version__ = version = "0.0.110"
 
 from . import aws
 from . import db

velocity/db/core/engine.py

@@ -327,146 +327,93 @@ class Engine:
 
     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)
-            
-        Raises:
-            The appropriate velocity exception with proper chaining
+        Central method to parse driver exceptions and re-raise them as our custom exceptions.
         """
         logger = logging.getLogger(__name__)
         
-        # Enhanced logging with context - more readable format
-        sql_preview = sql[:100] + "..." if sql and len(sql) > 100 else sql or "None"
-        
-        logger.error(
-            f"🔴 Database Error Detected\n"
-            f"   Exception Type: {type(exception).__name__}\n"
-            f"   SQL Statement: {sql_preview}\n"
-            f"   Processing error for classification..."
-        )
+        # If it's already a velocity exception, just re-raise it
+        if isinstance(exception, exceptions.DbException):
+            raise exception
         
-        # Safely get error code and message with fallbacks
+        # Get error code and message from the SQL driver
         try:
-            error_code = getattr(exception, 'pgcode', None) or self.get_error(exception)
-        except Exception as e:
-            logger.warning(f"⚠️  Unable to extract database error code: {e}")
-            error_code = None
-            
-        try:
-            error_message = str(exception)
-        except Exception as e:
-            logger.warning(f"⚠️  Unable 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"✅ Successfully classified error: {error_code} → {error_class}")
-                    try:
-                        raise 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')
-        ]
+            error_code, error_message = self.sql.get_error(exception)
+        except Exception:
+            error_code, error_message = None, str(exception)
         
-        # 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 match: '{pattern}' → {error_class}")
-                        raise self._create_exception_with_chaining(
-                            error_class, error_message, exception, sql, parameters
-                        )
-                except re.error as regex_error:
-                    logger.warning(f"⚠️  Regex pattern error for '{pattern}': {regex_error}")
-                    continue
-                except Exception as pattern_error:
-                    logger.error(f"❌ Error applying pattern '{pattern}': {pattern_error}")
-                    continue
+        msg = str(exception).strip().lower()
         
-        # Fallback: return generic database error with full context
-        available_codes = list(getattr(self, 'error_codes', {}).keys()) if hasattr(self, 'error_codes') else []
         logger.warning(
-            f"⚠️  Unable to classify database error automatically\n"
-            f"   → Falling back to generic DatabaseError\n"
-            f"   → Error Code: {error_code or 'Unknown'}\n"
-            f"   → Available Classifications: {available_codes or 'None configured'}"
+            "Database error caught. Attempting to transform: code=%s message=%s",
+            error_code,
+            error_message,
         )
         
-        raise self._create_exception_with_chaining(
-            'DatabaseError', error_message, exception, sql, parameters
+        # Direct error code mapping
+        if error_code in self.sql.ApplicationErrorCodes:
+            raise exceptions.DbApplicationError(str(exception)) from exception
+        if error_code in self.sql.ColumnMissingErrorCodes:
+            raise exceptions.DbColumnMissingError(str(exception)) from exception
+        if error_code in self.sql.TableMissingErrorCodes:
+            raise exceptions.DbTableMissingError(str(exception)) from exception
+        if error_code in self.sql.DatabaseMissingErrorCodes:
+            raise exceptions.DbDatabaseMissingError(str(exception)) from exception
+        if error_code in self.sql.ForeignKeyMissingErrorCodes:
+            raise exceptions.DbForeignKeyMissingError(str(exception)) from exception
+        if error_code in self.sql.TruncationErrorCodes:
+            raise exceptions.DbTruncationError(str(exception)) from exception
+        if error_code in self.sql.DataIntegrityErrorCodes:
+            raise exceptions.DbDataIntegrityError(str(exception)) from exception
+        if error_code in self.sql.ConnectionErrorCodes:
+            raise exceptions.DbConnectionError(str(exception)) from exception
+        if error_code in self.sql.DuplicateKeyErrorCodes:
+            raise exceptions.DbDuplicateKeyError(str(exception)) from exception
+        if error_code in self.sql.DatabaseObjectExistsErrorCodes:
+            raise exceptions.DbObjectExistsError(str(exception)) from exception
+        if error_code in self.sql.LockTimeoutErrorCodes:
+            raise exceptions.DbLockTimeoutError(str(exception)) from exception
+        if error_code in self.sql.RetryTransactionCodes:
+            raise exceptions.DbRetryTransaction(str(exception)) from exception
+            
+        # Regex-based fallback patterns
+        if re.search(r"key \(sys_id\)=\(\d+\) already exists.", msg, re.M):
+            raise exceptions.DbDuplicateKeyError(str(exception)) from exception
+        if re.findall(r"database.*does not exist", msg, re.M):
+            raise exceptions.DbDatabaseMissingError(str(exception)) from exception
+        if re.findall(r"no such database", msg, re.M):
+            raise exceptions.DbDatabaseMissingError(str(exception)) from exception
+        if re.findall(r"already exists", msg, re.M):
+            raise exceptions.DbObjectExistsError(str(exception)) from exception
+        if re.findall(r"server closed the connection unexpectedly", msg, re.M):
+            raise exceptions.DbConnectionError(str(exception)) from exception
+        if re.findall(r"no connection to the server", msg, re.M):
+            raise exceptions.DbConnectionError(str(exception)) from exception
+        if re.findall(r"connection timed out", msg, re.M):
+            raise exceptions.DbConnectionError(str(exception)) from exception
+        if re.findall(r"could not connect to server", msg, re.M):
+            raise exceptions.DbConnectionError(str(exception)) from exception
+        if re.findall(r"cannot connect to server", msg, re.M):
+            raise exceptions.DbConnectionError(str(exception)) from exception
+        if re.findall(r"connection already closed", msg, re.M):
+            raise exceptions.DbConnectionError(str(exception)) from exception
+        if re.findall(r"cursor already closed", msg, re.M):
+            raise exceptions.DbConnectionError(str(exception)) from exception
+        if "no such table:" in msg:
+            raise exceptions.DbTableMissingError(str(exception)) from exception
+        
+        logger.error(
+            "Unhandled/Unknown Error in engine.process_error",
+            exc_info=True,
+            extra={
+                "error_code": error_code,
+                "error_msg": error_message,
+                "sql_stmt": sql,
+                "sql_params": parameters,
+            },
         )
+        
+        # If we can't classify it, re-raise the original exception
+        raise exception
     
     def _format_human_readable_error(self, error_class, message, original_exception, sql=None, parameters=None, format_type='console'):
         """

{velocity_python-0.0.108.dist-info → velocity_python-0.0.110.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.108
+Version: 0.0.110
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.108.dist-info → velocity_python-0.0.110.dist-info}/RECORD

@@ -1,4 +1,4 @@
-velocity/__init__.py,sha256=--SXChkiTr8nQ6NCjSI78kO3i4IrqNpzMSXnF_CTEl4,107
+velocity/__init__.py,sha256=5Na4DTc1X43viY7Pm3xBOpXkedLfKb2sDq7Y3pK6Z8M,107
 velocity/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/invoices.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/orders.py,sha256=W-HAXEwY8-IFXbKh82HnMeRVZM7P-TWGEQOWtkLIzI4,6298
@@ -18,7 +18,7 @@ velocity/db/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 velocity/db/core/column.py,sha256=tAr8tL3a2nyaYpNHhGl508FrY_pGZTzyYgjAV5CEBv4,4092
 velocity/db/core/database.py,sha256=3zNGItklu9tZCKsbx2T2vCcU1so8AL9PPL0DLjvaz6s,3554
 velocity/db/core/decorators.py,sha256=76Jkr9XptXt8cvcgp1zbHfuL8uHzWy8lwfR29u-DVu4,4574
-velocity/db/core/engine.py,sha256=iLQSr9hvn4w78EGiCbS2WsiojQgPYRBW_EGjTS2074g,49225
+velocity/db/core/engine.py,sha256=ykF-UjYlDqDgD_KDLp7kiot-TEOrh5BifnPLyQEewgo,47549
 velocity/db/core/exceptions.py,sha256=tuDniRqTX8Opc2d033LPJOI3Ux4NSwUcHqW729n-HXA,1027
 velocity/db/core/result.py,sha256=dgiOXH-iJXuDH4PbSTWVkn-heAkJQcXCC-gs0ZuqF94,12814
 velocity/db/core/row.py,sha256=zZ3zZbWjZkZfYAYuZJLHFJ8jdXc7dYv8Iyv9Ut8W8tE,7261
@@ -49,8 +49,8 @@ velocity/misc/tools.py,sha256=_bGneHHA_BV-kUonzw5H3hdJ5AOJRCKfzhgpkFbGqIo,1502
 velocity/misc/conv/__init__.py,sha256=MLYF58QHjzfDSxb1rdnmLnuEQCa3gnhzzZ30CwZVvQo,40
 velocity/misc/conv/iconv.py,sha256=d4_BucW8HTIkGNurJ7GWrtuptqUf-9t79ObzjJ5N76U,10603
 velocity/misc/conv/oconv.py,sha256=h5Lo05DqOQnxoD3y6Px_MQP_V-pBbWf8Hkgkb9Xp1jk,6032
-velocity_python-0.0.108.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.108.dist-info/METADATA,sha256=gBHRoiRyaXBQHlbmh9tYPxR0DTV5ZU_8n2F3GEvjIW0,34262
-velocity_python-0.0.108.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-velocity_python-0.0.108.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.108.dist-info/RECORD,,
+velocity_python-0.0.110.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.110.dist-info/METADATA,sha256=KSop21_ZqWqh1EZNPMcOge75C9POxKMVG5ZQhg6NrrM,34262
+velocity_python-0.0.110.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+velocity_python-0.0.110.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.110.dist-info/RECORD,,