velocity-python 0.0.30__py3-none-any.whl → 0.0.31__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.30"
+__version__ = version = "0.0.31"
 
 from . import aws
 from . import db

velocity/aws/__init__.py

@@ -1,22 +1,18 @@
 import os
 import requests
 
-DEBUG = (os.environ.get('ENV') != 'production') \
-     or (os.environ.get('DEBUG') == 'Y')
+DEBUG = (os.environ.get("ENV") != "production") or (os.environ.get("DEBUG") == "Y")
 
 
 # This is helpful for running HTTPS clients on lambda.
-if os.path.exists('/opt/python/ca-certificates.crt'):
-    os.environ["REQUESTS_CA_BUNDLE"] = '/opt/python/ca-certificates.crt'
+if os.path.exists("/opt/python/ca-certificates.crt"):
+    os.environ["REQUESTS_CA_BUNDLE"] = "/opt/python/ca-certificates.crt"
 
 
 class AWS(object):
     # Get AWS EC2 Instance ID. Must run this from the EC2 instance itself to get the ID
     @staticmethod
     def instance_id(cls):
-        response = requests.get(
-            'http://169.254.169.254/latest/meta-data/instance-id')
+        response = requests.get("http://169.254.169.254/latest/meta-data/instance-id")
         instance_id = response.text
         return instance_id
-
-

velocity/db/core/column.py

@@ -1,10 +1,12 @@
 from velocity.db import exceptions
 from velocity.db.core.decorators import return_default
 
+
 class Column(object):
     """
     Represents a column in a database table.
     """
+
     def __init__(self, table, name):
         """
         Initializes a column object with the specified table and name.
@@ -12,11 +14,11 @@ class Column(object):
         Args:
             table (table): The table object that the column belongs to.
             name (str): The name of the column.
-        
+
         Raises:
             Exception: If the table parameter is not of type 'table'.
         """
-        if isinstance(table,str):
+        if isinstance(table, str):
             raise Exception("column table parameter must be a `table` class.")
         self.tx = table.tx
         self.sql = table.tx.engine.sql
@@ -39,13 +41,13 @@ class Column(object):
     NULL OK: %s
     Foreign Key: %s
         """ % (
-        self.table.name,
-        self.name,
-        self.exists(),
-        self.py_type,
-        self.sql_type,
-        self.is_nullok,
-        self.foreign_key_to
+            self.table.name,
+            self.name,
+            self.exists(),
+            self.py_type,
+            self.sql_type,
+            self.is_nullok,
+            self.foreign_key_to,
         )
 
     @property
@@ -55,7 +57,7 @@ class Column(object):
 
         Returns:
             dict: A dictionary containing information about the column.
-        
+
         Raises:
             DbColumnMissingError: If the column does not exist in the database.
         """
@@ -72,7 +74,7 @@ class Column(object):
 
         Returns:
             dict: A dictionary containing information about the foreign key constraint.
-        
+
         Raises:
             DbColumnMissingError: If the column does not exist in the database.
         """
@@ -89,12 +91,14 @@ class Column(object):
 
         Returns:
             str: The name of the referenced table and column in the format 'referenced_table_name.referenced_column_name'.
-        
+
         Raises:
             DbColumnMissingError: If the column does not exist in the database.
         """
         try:
-            return "{referenced_table_name}.{referenced_column_name}".format(**self.foreign_key_info)
+            return "{referenced_table_name}.{referenced_column_name}".format(
+                **self.foreign_key_info
+            )
         except exceptions.DbColumnMissingError:
             return None
 
@@ -105,12 +109,12 @@ class Column(object):
 
         Returns:
             str: The name of the referenced table.
-        
+
         Raises:
             DbColumnMissingError: If the column does not exist in the database.
         """
         try:
-            return self.foreign_key_info['referenced_table_name']
+            return self.foreign_key_info["referenced_table_name"]
         except exceptions.DbColumnMissingError:
             return None
 
@@ -167,7 +171,7 @@ class Column(object):
         self.name = name
 
     @return_default([])
-    def distinct(self, order='asc', qty=None):
+    def distinct(self, order="asc", qty=None):
         """
         Retrieves distinct values from the column.
 
@@ -178,7 +182,12 @@ class Column(object):
         Returns:
             list: A list of distinct values from the column.
         """
-        sql, vals = self.sql.select(columns="distinct {}".format(self.name), table=self.table.name, orderby="{} {}".format(self.name,order), qty=qty)
+        sql, vals = self.sql.select(
+            columns="distinct {}".format(self.name),
+            table=self.table.name,
+            orderby="{} {}".format(self.name, order),
+            qty=qty,
+        )
         return self.tx.execute(sql, vals).as_simple_list().all()
 
     def max(self, where=None):
@@ -190,13 +199,15 @@ class Column(object):
 
         Returns:
             int: The maximum value from the column.
-        
+
         Raises:
             DbTableMissingError: If the table does not exist in the database.
             DbColumnMissingError: If the column does not exist in the database.
         """
         try:
-            sql, vals = self.sql.select(columns="max({})".format(self.name), table=self.table.name, where=where)
+            sql, vals = self.sql.select(
+                columns="max({})".format(self.name), table=self.table.name, where=where
+            )
             return self.tx.execute(sql, vals).scalar()
-        except (exceptions.DbTableMissingError,exceptions.DbColumnMissingError):
+        except (exceptions.DbTableMissingError, exceptions.DbColumnMissingError):
             return 0

velocity/db/core/database.py

@@ -1,8 +1,8 @@
 class Database(object):
-    
+
     def __init__(self, tx, name=None):
         self.tx = tx
-        self.name = name or self.tx.engine.config['database']
+        self.name = name or self.tx.engine.config["database"]
         self.sql = tx.engine.sql
 
     def __str__(self):
@@ -12,10 +12,10 @@ class Database(object):
     (db exists) %s
     Tables: %s
         """ % (
-        self.tx.engine.sql.server,
-        self.name,
-        self.exists(),
-        len(self.tables)
+            self.tx.engine.sql.server,
+            self.name,
+            self.exists(),
+            len(self.tables),
         )
 
     def __enter__(self):
@@ -28,7 +28,7 @@ class Database(object):
     def close(self):
         try:
             self._cursor.close()
-            #print("*** database('{}').cursor.close()".format(self.name))
+            # print("*** database('{}').cursor.close()".format(self.name))
         except AttributeError:
             pass
 
@@ -37,7 +37,7 @@ class Database(object):
         try:
             return self._cursor
         except AttributeError:
-            #print("*** database('{}').cursor.open()".format(self.name))
+            # print("*** database('{}').cursor.open()".format(self.name))
             self._cursor = self.tx.cursor()
         return self._cursor
 
@@ -57,7 +57,7 @@ class Database(object):
     @property
     def tables(self):
         sql, vals = self.sql.tables()
-        result = self.tx.execute(sql ,vals, cursor=self.cursor)
+        result = self.tx.execute(sql, vals, cursor=self.cursor)
         return ["%s.%s" % x for x in result.as_tuple()]
 
     def reindex(self):

velocity/db/core/engine.py

@@ -4,6 +4,7 @@ from velocity.db.core.transaction import Transaction
 from functools import wraps
 import inspect, sys, re, traceback
 
+
 class Engine(object):
     MAX_RETRIES = 100
 
@@ -16,53 +17,52 @@ class Engine(object):
         return """[{}] engine({})""".format(self.sql.server, self.config)
 
     def connect(self):
-            """
-            Connects to the database and returns the connection object.
-
-            If the database is missing, it creates the database and then connects to it.
-
-            Returns:
-                conn: The connection object to the database.
-            """
-            try:
-                conn = self.__connect()
-            except exceptions.DbDatabaseMissingError:
-                self.create_database()
-                conn = self.__connect()
-            if self.sql.server == 'SQLite3':
-                conn.isolation_level = None
-            return conn
+        """
+        Connects to the database and returns the connection object.
+
+        If the database is missing, it creates the database and then connects to it.
+
+        Returns:
+            conn: The connection object to the database.
+        """
+        try:
+            conn = self.__connect()
+        except exceptions.DbDatabaseMissingError:
+            self.create_database()
+            conn = self.__connect()
+        if self.sql.server == "SQLite3":
+            conn.isolation_level = None
+        return conn
 
     def __connect(self):
-            """
-            Connects to the database using the provided configuration.
-
-            Returns:
-                A connection object representing the connection to the database.
-
-            Raises:
-                Exception: If the configuration parameter is not handled properly.
-                ProcessError is called to handle other exceptions.
-            """
-            try:
-                if isinstance(self.config, dict):
-                    return self.driver.connect(**self.config)
-                elif isinstance(self.config, (tuple, list)):
-                    return self.driver.connect(*self.config)
-                elif isinstance(self.config, str):
-                    return self.driver.connect(self.config)
-                else:
-                    raise Exception("Unhandled configuration parameter")
-            except:
-                self.ProcessError()
-         
+        """
+        Connects to the database using the provided configuration.
+
+        Returns:
+            A connection object representing the connection to the database.
+
+        Raises:
+            Exception: If the configuration parameter is not handled properly.
+            ProcessError is called to handle other exceptions.
+        """
+        try:
+            if isinstance(self.config, dict):
+                return self.driver.connect(**self.config)
+            elif isinstance(self.config, (tuple, list)):
+                return self.driver.connect(*self.config)
+            elif isinstance(self.config, str):
+                return self.driver.connect(self.config)
+            else:
+                raise Exception("Unhandled configuration parameter")
+        except:
+            self.ProcessError()
 
     def transaction(self, func_or_cls=None):
         """
-        Decorator for defining a transaction. Use this to wrap a function, method, or class to automatically 
-            start a transaction if necessary. If the function, method or class is called with a `tx` keyword argument, 
-            it will use that transaction object instead of creating a new one. If the function, method or class 
-            is called with a `tx` positional argument, it will use that transaction object instead of creating a new one. 
+        Decorator for defining a transaction. Use this to wrap a function, method, or class to automatically
+            start a transaction if necessary. If the function, method or class is called with a `tx` keyword argument,
+            it will use that transaction object instead of creating a new one. If the function, method or class
+            is called with a `tx` positional argument, it will use that transaction object instead of creating a new one.
             If the function, method or class is called with a `tx` positional argument and a `tx` keyword argument, it will use the positional
             argument and ignore the keyword argument. If the function, method or class is called without a `tx` argument,
             it will create a new transaction object and use that.
@@ -72,9 +72,9 @@ class Engine(object):
         Returns:
             If `func_or_cls` is a function or method, returns a wrapped version of the function or method that
             automatically starts a transaction if necessary. If `func_or_cls` is a class, returns a subclass of
-            `func_or_cls` that wraps all its methods with the transaction decorator. 
-            
- 
+            `func_or_cls` that wraps all its methods with the transaction decorator.
+
+
 
         If `func_or_cls` is not provided, returns a new `Transaction` object associated with the engine.
         """
@@ -86,55 +86,60 @@ class Engine(object):
         #           ...
         #
         engine = self
-        if inspect.isfunction(func_or_cls) \
-        or inspect.ismethod(func_or_cls):
+        if inspect.isfunction(func_or_cls) or inspect.ismethod(func_or_cls):
+
             @wraps(func_or_cls)
             def NewFunction(*args, **kwds):
                 tx = None
                 names = list(inspect.signature(func_or_cls).parameters.keys())
-                if '_tx' in names:
-                    raise NameError(f'In function named `{func_or_cls.__name__}` You may not name a paramater `_tx`')
-                if 'tx' not in names:
+                if "_tx" in names:
+                    raise NameError(
+                        f"In function named `{func_or_cls.__name__}` You may not name a paramater `_tx`"
+                    )
+                if "tx" not in names:
                     return func_or_cls(*args, **kwds)
-                elif 'tx' in kwds:
-                    if isinstance(kwds['tx'], Transaction):
-                        tx = kwds['tx']
+                elif "tx" in kwds:
+                    if isinstance(kwds["tx"], Transaction):
+                        tx = kwds["tx"]
                     else:
-                        raise TypeError(f'In function named `{func_or_cls.__name__}` keyword `tx` must be a Transaction object')
-                elif 'tx' in names:
-                    pos = names.index('tx')
-                    if len(args) > pos \
-                    and isinstance(args[pos], Transaction):
+                        raise TypeError(
+                            f"In function named `{func_or_cls.__name__}` keyword `tx` must be a Transaction object"
+                        )
+                elif "tx" in names:
+                    pos = names.index("tx")
+                    if len(args) > pos and isinstance(args[pos], Transaction):
                         tx = args[pos]
                 if tx:
                     return engine.exec_function(func_or_cls, tx, *args, **kwds)
                 else:
                     with Transaction(engine) as tx:
-                        pos = names.index('tx')
+                        pos = names.index("tx")
                         args = list(args)
                         args.insert(pos, tx)
                         args = tuple(args)
-                        return engine.exec_function(func_or_cls, tx, *args, **kwds) 
+                        return engine.exec_function(func_or_cls, tx, *args, **kwds)
+
             return NewFunction
         elif inspect.isclass(func_or_cls):
+
             class NewCls(func_or_cls):
                 def __getattribute__(self, key):
                     attr = super(NewCls, self).__getattribute__(key)
-                    if key in ['start_response']:
+                    if key in ["start_response"]:
                         return attr
                     if inspect.ismethod(attr):
                         return engine.transaction(attr)
                     return attr
+
             return NewCls
 
         return Transaction(engine)
-    
 
     def exec_function(self, function, _tx, *args, **kwds):
         """
         Executes the given function with the provided arguments and keyword arguments.
         If there is no transaction object, it executes the function without a transaction.
-        
+
         If there is a transaction object, it executes the function within the transaction.
         If the function raises a `DbRetryTransaction` exception, it rolls back the transaction and retries.
         If the function raises a `DbLockTimeoutError` exception, it rolls back the transaction and retries.
@@ -169,14 +174,14 @@ class Engine(object):
                     retry_count += 1
                     if retry_count > self.MAX_RETRIES:
                         raise
-                    print('**Retry Transaction. Rollback and start over')
+                    print("**Retry Transaction. Rollback and start over")
                     _tx.rollback()
                     continue
                 except exceptions.DbLockTimeoutError:
                     tmout_count += 1
                     if tmout_count > self.MAX_RETRIES:
                         raise
-                    print('**DbLockTimeoutError. Rollback and start over')
+                    print("**DbLockTimeoutError. Rollback and start over")
                     _tx.rollback()
                     continue
                 except:
@@ -228,22 +233,22 @@ class Engine(object):
     def create_database(self, name=None):
         old = None
         if name == None:
-            old = self.config['database']
-            self.set_config({'database':'postgres'})
+            old = self.config["database"]
+            self.set_config({"database": "postgres"})
             name = old
         with Transaction(self) as tx:
             sql, vals = self.sql.create_database(name)
             tx.execute(sql, vals, single=True)
         if old:
-            self.set_config({'database':old})
+            self.set_config({"database": old})
         return self
 
     def switch_to_database(self, database):
-        conf  = self.config
-        if 'database' in conf:
-            conf['database'] = database
-        if 'dbname' in conf:
-            conf['dbname'] = database
+        conf = self.config
+        if "database" in conf:
+            conf["database"] = database
+        if "dbname" in conf:
+            conf["dbname"] = database
         return self
 
     def set_config(self, config):
@@ -276,27 +281,24 @@ class Engine(object):
             result = tx.execute(sql, vals)
             return ["%s.%s" % x for x in result.as_tuple()]
 
-
     def ProcessError(self, sql_stmt=None, sql_params=None):
         sql = self.sql
         e = sys.exc_info()[1]
         msg = str(e).strip().lower()
-        if isinstance(e,exceptions.DbException):
+        if isinstance(e, exceptions.DbException):
             raise
-        if hasattr(e,'pgcode'):
+        if hasattr(e, "pgcode"):
             error_code = e.pgcode
             error_mesg = e.pgerror
-        elif hasattr(e,'args') \
-        and isinstance(e.args,(tuple,list)) \
-        and len(e.args) > 1:
+        elif (
+            hasattr(e, "args") and isinstance(e.args, (tuple, list)) and len(e.args) > 1
+        ):
             error_code = e[0]
             error_mesg = e[1]
-        elif hasattr(e,'number') \
-        and hasattr(e,'text'):
+        elif hasattr(e, "number") and hasattr(e, "text"):
             error_code = e.number
             error_mesg = e.text
-        elif hasattr(e,'args') \
-        and hasattr(e,'message'):
+        elif hasattr(e, "args") and hasattr(e, "message"):
             # SQLite3
             error_code = None
             error_mesg = e.message
@@ -320,7 +322,7 @@ class Engine(object):
             raise exceptions.DbConnectionError(e)
         elif error_code in sql.DuplicateKeyErrorCodes:
             raise exceptions.DbDuplicateKeyError(e)
-        elif re.search('key \(sys_id\)=\(\d+\) already exists.', msg, re.M):
+        elif re.search("key \(sys_id\)=\(\d+\) already exists.", msg, re.M):
             raise exceptions.DbDuplicateKeyError(e)
         elif error_code in sql.DatabaseObjectExistsErrorCodes:
             raise exceptions.DbObjectExistsError(e)
@@ -328,34 +330,34 @@ class Engine(object):
             raise exceptions.DbLockTimeoutError(e)
         elif error_code in sql.RetryTransactionCodes:
             raise exceptions.DbRetryTransaction(e)
-        elif re.findall('database.*does not exist', msg, re.M):
+        elif re.findall("database.*does not exist", msg, re.M):
             raise exceptions.DbDatabaseMissingError(e)
-        elif re.findall('no such database', msg, re.M):
+        elif re.findall("no such database", msg, re.M):
             raise exceptions.DbDatabaseMissingError(e)
-        elif re.findall('already exists', msg, re.M):
+        elif re.findall("already exists", msg, re.M):
             raise exceptions.DbObjectExistsError(e)
-        elif re.findall('server closed the connection unexpectedly', msg, re.M):
+        elif re.findall("server closed the connection unexpectedly", msg, re.M):
             raise exceptions.DbConnectionError(e)
-        elif re.findall('no connection to the server', msg, re.M):
+        elif re.findall("no connection to the server", msg, re.M):
             raise exceptions.DbConnectionError(e)
-        elif re.findall('connection timed out', msg, re.M):
+        elif re.findall("connection timed out", msg, re.M):
             raise exceptions.DbConnectionError(e)
-        elif re.findall('could not connect to server', msg, re.M):
+        elif re.findall("could not connect to server", msg, re.M):
             raise exceptions.DbConnectionError(e)
-        elif re.findall('cannot connect to server', msg, re.M):
+        elif re.findall("cannot connect to server", msg, re.M):
             raise exceptions.DbConnectionError(e)
-        elif re.findall('connection already closed', msg, re.M):
+        elif re.findall("connection already closed", msg, re.M):
             raise exceptions.DbConnectionError(e)
-        elif re.findall('cursor already closed', msg, re.M):
+        elif re.findall("cursor already closed", msg, re.M):
             raise exceptions.DbConnectionError(e)
         # SQLite3 errors
-        elif 'no such table:' in msg:
+        elif "no such table:" in msg:
             raise exceptions.DbTableMissingError(e)
         print("Unhandled/Unknown Error in connection.ProcessError")
-        print('EXC_TYPE = {}'.format(type(e)))
-        print('EXC_MSG = {}'.format(str(e).strip()))
-        print('ERROR_CODE = {}'.format(error_code))
-        print('ERROR_MSG = {}'.format(error_mesg))
+        print("EXC_TYPE = {}".format(type(e)))
+        print("EXC_MSG = {}".format(str(e).strip()))
+        print("ERROR_CODE = {}".format(error_code))
+        print("ERROR_MSG = {}".format(error_mesg))
         if sql_stmt:
             print("\n")
             print("sql_stmt [velocity.db.engine]: {}".format(sql_stmt))

velocity/db/core/exceptions.py

@@ -1,31 +1,54 @@
 class DbException(Exception):
     pass
 
+
 class DbApplicationError(DbException):
     pass
 
+
 class DbForeignKeyMissingError(DbException):
     pass
+
+
 class DbDatabaseMissingError(DbException):
     pass
+
+
 class DbTableMissingError(DbException):
     pass
+
+
 class DbColumnMissingError(DbException):
     pass
 
+
 class DbTruncationError(DbException):
     pass
+
+
 class DbConnectionError(DbException):
     pass
+
+
 class DbDuplicateKeyError(DbException):
     pass
+
+
 class DbObjectExistsError(DbException):
     pass
+
+
 class DbLockTimeoutError(DbException):
     pass
+
+
 class DbRetryTransaction(DbException):
     pass
+
+
 class DbDataIntegrityError(DbException):
     pass
+
+
 class DuplicateRowsFoundError(Exception):
     pass

velocity/db/core/sequence.py

@@ -10,10 +10,15 @@ class Sequence(object):
     def __str__(self):
         return """
     Sequence: %s
-        """ % ( self.name )
+        """ % (
+            self.name
+        )
 
     def create(self):
-        sql, vals = "CREATE SEQUENCE IF NOT EXISTS {} START {};".format(self.name, self.start), tuple()
+        sql, vals = (
+            "CREATE SEQUENCE IF NOT EXISTS {} START {};".format(self.name, self.start),
+            tuple(),
+        )
         return self.tx.execute(sql, vals)
 
     def next(self):
@@ -25,7 +30,10 @@ class Sequence(object):
         return self.tx.execute(sql, vals).scalar()
 
     def reset(self, start=None):
-        sql, vals = "ALTER SEQUENCE {} RESTART WITH {};".format(self.name, start or self.start), tuple()
+        sql, vals = (
+            "ALTER SEQUENCE {} RESTART WITH {};".format(self.name, start or self.start),
+            tuple(),
+        )
         return self.tx.execute(sql, vals).scalar()
 
     def drop(self):