velocity-python 0.0.116__py3-none-any.whl → 0.0.118__py3-none-any.whl

velocity/db/exceptions.py

@@ -5,108 +5,125 @@ Database exceptions for the velocity library.
 
 class DbException(Exception):
     """Base class for all database exceptions."""
+
     pass
 
 
 class DbApplicationError(DbException):
     """Application-level database error."""
+
     pass
 
 
 class DbForeignKeyMissingError(DbException):
     """Foreign key constraint violation."""
+
     pass
 
 
 class DbDatabaseMissingError(DbException):
     """Database does not exist."""
+
     pass
 
 
 class DbTableMissingError(DbException):
     """Table does not exist."""
+
     pass
 
 
 class DbColumnMissingError(DbException):
     """Column does not exist."""
+
     pass
 
 
 class DbTruncationError(DbException):
     """Data truncation error."""
+
     pass
 
 
 class DbConnectionError(DbException):
     """Database connection error."""
+
     pass
 
 
 class DbDuplicateKeyError(DbException):
     """Duplicate key constraint violation."""
+
     pass
 
 
 class DbObjectExistsError(DbException):
     """Database object already exists."""
+
     pass
 
 
 class DbLockTimeoutError(DbException):
     """Lock timeout error."""
+
     pass
 
 
 class DbRetryTransaction(DbException):
     """Transaction should be retried."""
+
     pass
 
 
 class DbDataIntegrityError(DbException):
     """Data integrity constraint violation."""
+
     pass
 
 
 class DbQueryError(DbException):
     """Database query error."""
+
     pass
 
 
 class DbTransactionError(DbException):
     """Database transaction error."""
+
     pass
 
 
 class DuplicateRowsFoundError(Exception):
     """Multiple rows found when expecting single result."""
+
     pass
 
 
 # Add aliases for backward compatibility with engine.py
 class DatabaseError(DbException):
     """Generic database error - alias for DbException."""
+
     pass
 
+
 __all__ = [
     # Base exceptions
-    'DbException',
-    'DatabaseError',
-    
+    "DbException",
+    "DatabaseError",
     # Specific exceptions
-    'DbApplicationError',
-    'DbForeignKeyMissingError', 
-    'DbDatabaseMissingError',
-    'DbTableMissingError',
-    'DbColumnMissingError',
-    'DbTruncationError',
-    'DbConnectionError',
-    'DbDuplicateKeyError',
-    'DbObjectExistsError',
-    'DbLockTimeoutError',
-    'DbRetryTransaction',
-    'DbDataIntegrityError',
-    'DbQueryError',
-    'DbTransactionError',
-    'DuplicateRowsFoundError',
+    "DbApplicationError",
+    "DbForeignKeyMissingError",
+    "DbDatabaseMissingError",
+    "DbTableMissingError",
+    "DbColumnMissingError",
+    "DbTruncationError",
+    "DbConnectionError",
+    "DbDuplicateKeyError",
+    "DbObjectExistsError",
+    "DbLockTimeoutError",
+    "DbRetryTransaction",
+    "DbDataIntegrityError",
+    "DbQueryError",
+    "DbTransactionError",
+    "DuplicateRowsFoundError",
 ]

velocity/db/servers/mysql.py

@@ -30,7 +30,7 @@ def make_where(where, sql, vals, is_join=False):
             if is_join:
                 if "." not in key:
                     key = "A." + key
-            if val == None:
+            if val is None:
                 if "!" in key:
                     key = key.replace("!", "")
                     sql.append("{} is not NULL".format(quote(key.lower())))
@@ -198,7 +198,7 @@ class SQL:
         cls, table, columns, key_to_table, key_to_columns, name=None, schema=None
     ):
         if "." not in table and schema:
-            if schema == None:
+            if schema is None:
                 schema = cls.default_schema
             table = "{}.{}".format(schema, table)
         if isinstance(key_to_columns, str):
@@ -254,7 +254,6 @@ class SQL:
 
     @classmethod
     def create_table(cls, name, columns={}, drop=False):
-        trigger = "".format(name)
         sql = []
         if drop:
             sql.append(cls.drop_table(name))

velocity/db/servers/postgres/__init__.py

@@ -4,16 +4,14 @@ from .sql import SQL
 from velocity.db.core import engine
 
 
-
 def initialize(config=None, **kwargs):
-    if not config:
-        # Keep the default config inside this function.
-        config = {
-            "database": os.environ["DBDatabase"],
-            "host": os.environ["DBHost"],
-            "port": os.environ["DBPort"],
-            "user": os.environ["DBUser"],
-            "password": os.environ["DBPassword"],
-        }
-    config.update(kwargs)
-    return engine.Engine(psycopg2, config, SQL)
+    konfig = {
+        "database": os.environ["DBDatabase"],
+        "host": os.environ["DBHost"],
+        "port": os.environ["DBPort"],
+        "user": os.environ["DBUser"],
+        "password": os.environ["DBPassword"],
+    }
+    konfig.update(config or {})
+    konfig.update(kwargs)
+    return engine.Engine(psycopg2, konfig, SQL)

velocity/db/servers/postgres/sql.py

@@ -1,7 +1,7 @@
 import re
 import hashlib
 import sqlparse
-from psycopg2 import sql
+from psycopg2 import sql as psycopg2_sql
 
 from velocity.db import exceptions
 
@@ -37,7 +37,7 @@ def _handle_predicate_errors(predicates, operation="WHERE"):
     """Process a list of predicates with error handling."""
     sql_parts = []
     vals = []
-    
+
     for pred, val in predicates:
         sql_parts.append(pred)
         if val is None:
@@ -46,7 +46,7 @@ def _handle_predicate_errors(predicates, operation="WHERE"):
             vals.extend(val)
         else:
             vals.append(val)
-    
+
     return sql_parts, vals
 
 
@@ -75,8 +75,19 @@ class SQL:
     ColumnMissingErrorCodes = ["42703"]
     ForeignKeyMissingErrorCodes = ["42704"]
 
-    ConnectionErrorCodes = ["08001", "08S01", "57P03", "08006", "53300", "08003", "08004", "08P01"]
-    DuplicateKeyErrorCodes = ["23505"]  # unique_violation - no longer relying only on regex
+    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"]
@@ -111,7 +122,7 @@ class SQL:
         """
         if not table:
             raise ValueError("Table name is required.")
-            
+
         # Validate pagination parameters
         if start is not None and not isinstance(start, int):
             raise ValueError("Start (OFFSET) must be an integer.")
@@ -148,7 +159,7 @@ class SQL:
         columns = [c.strip() for c in columns if c.strip()]  # Remove empty columns
         if not columns:
             raise ValueError("No valid columns specified")
-            
+
         distinct = False
 
         # Check for DISTINCT keyword in any column
@@ -188,7 +199,7 @@ class SQL:
         new_orderby = []
         if isinstance(orderby, str):
             orderby = th.split_columns(orderby)
-            
+
         # Handle orderby references
         if isinstance(orderby, Sequence):
             for column in orderby:
@@ -200,7 +211,9 @@ class SQL:
                             # Validate direction
                             direction = direction.upper()
                             if direction not in ("ASC", "DESC"):
-                                raise ValueError(f"Invalid ORDER BY direction: {direction}")
+                                raise ValueError(
+                                    f"Invalid ORDER BY direction: {direction}"
+                                )
                             col_name = th.resolve_references(
                                 col_name.strip(), options={"alias_only": True}
                             )
@@ -213,7 +226,9 @@ class SQL:
                         )
                         new_orderby.append(resolved_col)
                 except Exception as e:
-                    raise ValueError(f"Error processing ORDER BY column '{column}': {e}")
+                    raise ValueError(
+                        f"Error processing ORDER BY column '{column}': {e}"
+                    )
 
         elif isinstance(orderby, Mapping):
             for key, val in orderby.items():
@@ -222,11 +237,13 @@ class SQL:
                     direction = str(val).upper()
                     if direction not in ("ASC", "DESC"):
                         raise ValueError(f"Invalid ORDER BY direction: {direction}")
-                    parsed_key = th.resolve_references(key, options={"alias_only": True})
+                    parsed_key = th.resolve_references(
+                        key, options={"alias_only": True}
+                    )
                     new_orderby.append(f"{parsed_key} {direction}")
                 except Exception as e:
                     raise ValueError(f"Error processing ORDER BY key '{key}': {e}")
-                    
+
         orderby = new_orderby
 
         # Handle groupby
@@ -256,7 +273,9 @@ class SQL:
 
         # FROM clause
         if th.foreign_keys:
-            sql_parts["FROM"].append(f"{TableHelper.quote(table)} AS {TableHelper.quote(alias)}")
+            sql_parts["FROM"].append(
+                f"{TableHelper.quote(table)} AS {TableHelper.quote(alias)}"
+            )
             # Handle joins
             done = []
             for key, ref_info in th.foreign_keys.items():
@@ -463,7 +482,7 @@ class SQL:
         # Create a temporary TableHelper instance for quoting
         # Note: We pass None for tx since we only need quoting functionality
         temp_helper = TableHelper(None, table)
-        
+
         keys = []
         vals_placeholders = []
         args = []
@@ -966,7 +985,7 @@ class SQL:
             columns = TableHelper.quote(columns)
         sql = ["DROP"]
         sql.append("INDEX IF EXISTS")
-        tablename = TableHelper.quote(table)
+        _tablename = TableHelper.quote(table)
         if not name:
             name = re.sub(
                 r"\([^)]*\)",
@@ -1136,9 +1155,9 @@ class SQL:
     @classmethod
     def missing(cls, tx, table, list, column="SYS_ID", where=None):
         sql = [
-            f"SELECT * FROM",
+            "SELECT * FROM",
             f"UNNEST('{{{','.join([str(x) for x in list])}}}'::int[]) id",
-            f"EXCEPT ALL",
+            "EXCEPT ALL",
             f"SELECT {column} FROM {table}",
         ]
         vals = []

velocity/db/servers/sqlite.py

@@ -216,7 +216,7 @@ class SQL(object):
                     if is_join:
                         if "." not in key:
                             key = "A." + key
-                    if val == None:
+                    if val is None:
                         if "!" in key:
                             key = key.replace("!", "")
                             sql.append("{} is not NULL".format(quote(key.lower())))
@@ -919,7 +919,7 @@ class SQL(object):
             for key in sorted(where.keys()):
                 if join:
                     sql.append(join)
-                if where[key] == None:
+                if where[key] is None:
                     sql.append("{} is NULL".format(quote(key.lower())))
                 else:
                     sql.append("{} = ?".format(quote(key.lower())))

velocity/db/servers/sqlserver.py

@@ -30,7 +30,7 @@ def make_where(where, sql, vals, is_join=False):
             if is_join:
                 if "." not in key:
                     key = "A." + key
-            if val == None:
+            if val is None:
                 if "!" in key:
                     key = key.replace("!", "")
                     sql.append("{} is not NULL".format(quote(key.lower())))
@@ -394,7 +394,7 @@ class SQL:
         cls, table, columns, key_to_table, key_to_columns, name=None, schema=None
     ):
         if "." not in table and schema:
-            if schema == None:
+            if schema is None:
                 schema = cls.default_schema
             table = "{}.{}".format(schema, table)
         if isinstance(key_to_columns, str):
@@ -873,7 +873,7 @@ class SQL:
             for key in sorted(where.keys()):
                 if join:
                     sql.append(join)
-                if where[key] == None:
+                if where[key] is None:
                     sql.append("{} is NULL".format(quote(key.lower())))
                 else:
                     sql.append("{} = %s".format(quote(key.lower())))