velocity-python 0.0.109__tar.gz → 0.0.110__tar.gz

{velocity_python-0.0.109 → velocity_python-0.0.110}/PKG-INFO

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

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

{velocity_python-0.0.109 → velocity_python-0.0.110}/src/velocity/__init__.py

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

{velocity_python-0.0.109 → velocity_python-0.0.110}/src/velocity/db/core/engine.py

@@ -24,38 +24,6 @@ class Engine:
         self.__sql = sql
         self.__driver = driver
         self.__connect_timeout = connect_timeout
-        
-        # Set up error code mappings from the SQL class
-        self._setup_error_mappings()
-
-    def _setup_error_mappings(self):
-        """
-        Set up error code to exception class mappings from the SQL driver.
-        """
-        self.error_codes = {}
-        
-        # Map error codes to exception class names
-        sql_attrs = [
-            ('ApplicationErrorCodes', 'DbApplicationError'),
-            ('DatabaseMissingErrorCodes', 'DbDatabaseMissingError'),
-            ('TableMissingErrorCodes', 'DbTableMissingError'), 
-            ('ColumnMissingErrorCodes', 'DbColumnMissingError'),
-            ('ForeignKeyMissingErrorCodes', 'DbForeignKeyMissingError'),
-            ('ConnectionErrorCodes', 'DbConnectionError'),
-            ('DuplicateKeyErrorCodes', 'DbDuplicateKeyError'),
-            ('RetryTransactionCodes', 'DbRetryTransaction'),
-            ('TruncationErrorCodes', 'DbTruncationError'),
-            ('LockTimeoutErrorCodes', 'DbLockTimeoutError'),
-            ('DatabaseObjectExistsErrorCodes', 'DbObjectExistsError'),
-            ('DataIntegrityErrorCodes', 'DbDataIntegrityError')
-        ]
-        
-        for attr_name, exception_class in sql_attrs:
-            if hasattr(self.sql, attr_name):
-                codes = getattr(self.sql, attr_name)
-                if codes:  # Only add non-empty lists
-                    for code in codes:
-                        self.error_codes[str(code)] = exception_class
 
     def __str__(self):
         return f"[{self.sql.server}] engine({self.config})"
@@ -359,161 +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
-        try:
-            # Try PostgreSQL-specific error code first, then use SQL driver's get_error method
-            error_code = getattr(exception, 'pgcode', None)
-            if not error_code and hasattr(self.sql, 'get_error'):
-                try:
-                    error_code, error_message_from_driver = self.sql.get_error(exception)
-                    if error_message_from_driver:
-                        error_message = error_message_from_driver
-                except Exception as get_error_exception:
-                    logger.warning(f"⚠️  SQL driver get_error failed: {get_error_exception}")
-                    error_code = None
-        except Exception as e:
-            logger.warning(f"⚠️  Unable to extract database error code: {e}")
-            error_code = None
-            
+        # Get error code and message from the SQL driver
         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') and str(error_code) in self.error_codes:
-            error_class = self.error_codes[str(error_code)]
-            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
-        
-        # 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 column missing patterns
-        column_missing_patterns = [
-            r'column.*does.*not.*exist',
-            r'unknown.*column|column.*not.*found',
-            r'no.*such.*column|invalid.*column.*name'
-        ]
-        
-        # 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'
-        ]
+            error_code, error_message = self.sql.get_error(exception)
+        except Exception:
+            error_code, error_message = None, str(exception)
         
-        # Comprehensive pattern matching with error class mapping
-        pattern_mappings = [
-            (connection_patterns, 'DbConnectionError'),
-            (duplicate_patterns, 'DbDuplicateKeyError'), 
-            (permission_patterns, 'DbPermissionError'),
-            (not_found_patterns, 'DbTableMissingError'),
-            (column_missing_patterns, 'DbColumnMissingError'),
-            (syntax_patterns, 'DbSyntaxError'),
-            (deadlock_patterns, 'DbDeadlockError')
-        ]
+        msg = str(exception).strip().lower()
         
-        # 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
-        
-        # 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.109 → velocity_python-0.0.110}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.109
+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