velocity-python 0.0.1__py3-none-any.whl

velocity/__init__.py

@@ -0,0 +1,3 @@
+from . import aws
+from . import db
+from . import misc  

velocity/aws/__init__.py

@@ -0,0 +1,24 @@
+import os
+import requests
+
+from velocity.aws.handlers import LambdaHandler
+from velocity.aws.handlers import SqsHandler
+
+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'
+
+
+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')
+        instance_id = response.text
+        return instance_id
+
+

velocity/aws/handlers/__init__.py

@@ -0,0 +1,2 @@
+from velocity.aws.handlers.lambda_handler import LambdaHandler
+from velocity.aws.handlers.sqs_handler import SqsHandler

velocity/aws/handlers/lambda_handler.py

@@ -0,0 +1,123 @@
+from velocity.misc.format import to_json
+import json
+import pprint
+import traceback
+
+class LambdaHandler:
+    def __init__(self, event, context):
+        self.event = event
+        self.context = context
+        self.serve_action_default = True
+
+        requestContext = event.get('requestContext', {})
+        identity = requestContext.get('identity', {})
+        headers = event.get('headers', {})
+        self.session = {
+            'authentication_provider':
+            identity.get('cognitoAuthenticationProvider'),
+            'authentication_type':
+            identity.get('cognitoAuthenticationType'),
+            'cognito_user':
+            identity.get('user'),
+            'is_desktop':
+            headers.get('CloudFront-Is-Desktop-Viewer') == 'true',
+            'is_mobile':
+            headers.get('CloudFront-Is-Mobile-Viewer') == 'true',
+            'is_smart_tv':
+            headers.get('CloudFront-Is-SmartTV-Viewer') == 'true',
+            'is_tablet':
+            headers.get('CloudFront-Is-Tablet-Viewer') == 'true',
+            'origin':
+            headers.get('origin'),
+            'path':
+            event.get('path'),
+            'referer':
+            headers.get('Referer'),
+            'source_ip':
+            identity.get('sourceIp'),
+            'user_agent':
+            identity.get('userAgent'),
+        }
+        if self.session.get('is_mobile'):
+            self.session['device_type'] = 'mobile'
+        elif self.session.get('is_desktop'):
+            self.session['device_type'] = 'desktop'
+        elif self.session.get('is_tablet'):
+            self.session['device_type'] = 'tablet'
+        elif self.session.get('is_smart_tv'):
+            self.session['device_type'] = 'smart_tv'
+        else:
+            self.session['device_type'] = 'unknown'
+
+    def serve(self, tx):
+        response = {
+            'statusCode': 200,
+            'body': '{}',
+            'headers': {
+                'Content-Type': 'application/json',
+                "Access-Control-Allow-Origin": "*",
+            },
+        }
+        try:
+            postdata = {}
+            if self.event.get('body'):
+                postdata = json.loads(self.event.get('body'))
+            req_params = self.event.get('queryStringParameters') or {}
+            if hasattr(self, 'beforeAction'):
+                self.beforeAction(args=req_params,
+                                  postdata=postdata,
+                                  response=response)
+            actions = []
+            action = postdata.get('action', req_params.get('action'))
+            if action:
+                actions.append(
+                    f"on action {action.replace('-', ' ').replace('_', ' ')}".
+                    title().replace(' ', ''))
+            if self.serve_action_default:
+                actions.append('OnActionDefault')
+            for action in actions:
+                if hasattr(self, action):
+                    getattr(self, action)(args=req_params,
+                                          postdata=postdata,
+                                          response=response)
+                    break
+            if hasattr(self, 'afterAction'):
+                self.afterAction(args=req_params,
+                                 postdata=postdata,
+                                 response=response)
+
+        except Exception as e:
+            response = {
+                'statusCode':
+                500,
+                'body':
+                to_json({
+                    'type': 'Unhandled Exception',
+                    'error_message': str(e),
+                    'user_message': 'Oops! An unhandled error occurred.',
+                    'traceback': traceback.format_exc() if DEBUG else None
+                }),
+                'headers': {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*'
+                }
+            }
+            if hasattr(self, 'onError'):
+                self.onError(args=req_params,
+                             postdata=postdata,
+                             response=response,
+                             exc=e,
+                             tb=traceback.format_exc())
+
+        return response
+
+    def OnActionDefault(self, tx, args, postdata, response):
+        response['body'] = to_json({'event': self.event, 'postdata': postdata})
+
+    def onError(self, tx, args, postdata, response, exc, tb):
+        pprint.pprint({
+            'message': 'Unhandled Exception',
+            'exception': str(exc),
+            'traceback': traceback.format_exc()
+        })
+

velocity/aws/handlers/sqs_handler.py

@@ -0,0 +1,48 @@
+from velocity.misc.format import to_json
+import json
+import traceback
+
+class SqsHandler:
+    def __init__(self, event, context):
+        self.event = event
+        self.context = context
+        self.serve_action_default = True
+
+    def serve(self, tx):
+        records = self.event.get('Records', [])
+        print(f"Handling batch of {len(records)} records from SQS")
+        for record in records:
+            print(f"Start MessageId {record.get('messageId')}")
+            attrs = record.get('attributes')
+            try:
+                postdata = {}
+                if record.get('body'):
+                    postdata = json.loads(record.get('body'))
+                if hasattr(self, 'beforeAction'):
+                    self.beforeAction(attrs=attrs, postdata=postdata)
+                actions = []
+                action = postdata.get('action')
+                if action:
+                    actions.append(
+                        f"on action {action.replace('-', ' ').replace('_', ' ')}"
+                        .title().replace(' ', ''))
+                if self.serve_action_default:
+                    actions.append('OnActionDefault')
+                for action in actions:
+                    if hasattr(self, action):
+                        getattr(self, action)(attrs=attrs, postdata=postdata)
+                        break
+                if hasattr(self, 'afterAction'):
+                    self.afterAction(attrs=attrs, postdata=postdata)
+            except Exception as e:
+                if hasattr(self, 'onError'):
+                    self.onError(attrs=attrs,
+                                 postdata=postdata,
+                                 exc=e,
+                                 tb=traceback.format_exc())
+
+    def OnActionDefault(self, tx, attrs, postdata):
+        print(
+            "Action handler not found. Calling default action `SqsHandler.OnActionDefault` with the following parameters for tx, attrs, and postdata:"
+        )
+        print({'tx': tx, 'attrs': attrs, 'postdata': postdata})

velocity/db/__init__.py

@@ -0,0 +1,5 @@
+from velocity.db.core import exceptions
+from velocity.db.servers import postgres
+from velocity.db.servers import mysql
+from velocity.db.servers import sqlite
+from velocity.db.servers import sqlserver

velocity/db/core/column.py

@@ -0,0 +1,202 @@
+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.
+
+        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):
+            raise Exception("column table parameter must be a `table` class.")
+        self.tx = table.tx
+        self.sql = table.tx.engine.sql
+        self.name = name
+        self.table = table
+
+    def __str__(self):
+        """
+        Returns a string representation of the column object.
+
+        Returns:
+            str: A string representation of the column object.
+        """
+        return """
+    Table: %s
+    Column: %s
+    Column Exists: %s
+    Py Type: %s
+    SQL Type: %s
+    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
+        )
+
+    @property
+    def info(self):
+        """
+        Retrieves information about the column from the database.
+
+        Returns:
+            dict: A dictionary containing information about the column.
+        
+        Raises:
+            DbColumnMissingError: If the column does not exist in the database.
+        """
+        sql, vals = self.sql.column_info(self.table.name, self.name)
+        result = self.tx.execute(sql, vals).one()
+        if not result:
+            raise exceptions.DbColumnMissingError
+        return result
+
+    @property
+    def foreign_key_info(self):
+        """
+        Retrieves information about the foreign key constraint on the column.
+
+        Returns:
+            dict: A dictionary containing information about the foreign key constraint.
+        
+        Raises:
+            DbColumnMissingError: If the column does not exist in the database.
+        """
+        sql, vals = self.sql.foreign_key_info(table=self.table.name, column=self.name)
+        result = self.tx.execute(sql, vals).one()
+        if not result:
+            raise exceptions.DbColumnMissingError
+        return result
+
+    @property
+    def foreign_key_to(self):
+        """
+        Retrieves the name of the referenced table and column for the foreign key constraint.
+
+        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)
+        except exceptions.DbColumnMissingError:
+            return None
+
+    @property
+    def foreign_key_table(self):
+        """
+        Retrieves the name of the referenced table for the foreign key constraint.
+
+        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']
+        except exceptions.DbColumnMissingError:
+            return None
+
+    def exists(self):
+        """
+        Checks if the column exists in the table.
+
+        Returns:
+            bool: True if the column exists, False otherwise.
+        """
+        return self.name in self.table.columns
+
+    @property
+    def py_type(self):
+        """
+        Retrieves the Python data type of the column.
+
+        Returns:
+            type: The Python data type of the column.
+        """
+        return self.sql.py_type(self.sql_type)
+
+    @property
+    def sql_type(self):
+        """
+        Retrieves the SQL data type of the column.
+
+        Returns:
+            str: The SQL data type of the column.
+        """
+        return self.info[self.sql.type_column_identifier]
+
+    @property
+    def is_nullable(self):
+        """
+        Checks if the column is nullable.
+
+        Returns:
+            bool: True if the column is nullable, False otherwise.
+        """
+        return self.info[self.sql.is_nullable]
+
+    is_nullok = is_nullable
+
+    def rename(self, name):
+        """
+        Renames the column.
+
+        Args:
+            name (str): The new name for the column.
+        """
+        sql, vals = self.sql.rename_column(self.table.name, self.name, name)
+        self.tx.execute(sql, vals)
+        self.name = name
+
+    @return_default([])
+    def distinct(self, order='asc', qty=None):
+        """
+        Retrieves distinct values from the column.
+
+        Args:
+            order (str, optional): The order in which the values should be sorted. Defaults to 'asc'.
+            qty (int, optional): The maximum number of distinct values to retrieve. Defaults to None.
+
+        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)
+        return self.tx.execute(sql, vals).as_simple_list().all()
+
+    def max(self, where=None):
+        """
+        Retrieves the maximum value from the column.
+
+        Args:
+            where (str, optional): The WHERE clause to filter the rows. Defaults to None.
+
+        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)
+            return self.tx.execute(sql, vals).scalar()
+        except (exceptions.DbTableMissingError,exceptions.DbColumnMissingError):
+            return 0

velocity/db/core/database.py

@@ -0,0 +1,65 @@
+class Database(object):
+    
+    def __init__(self, tx, name=None):
+        self.tx = tx
+        self.name = name or self.tx.engine.config['database']
+        self.sql = tx.engine.sql
+
+    def __str__(self):
+        return """
+    Engine: %s
+    Database: %s
+    (db exists) %s
+    Tables: %s
+        """ % (
+        self.tx.engine.sql.server,
+        self.name,
+        self.exists(),
+        len(self.tables)
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not exc_type:
+            self.close()
+
+    def close(self):
+        try:
+            self._cursor.close()
+            #print("*** database('{}').cursor.close()".format(self.name))
+        except AttributeError:
+            pass
+
+    @property
+    def cursor(self):
+        try:
+            return self._cursor
+        except AttributeError:
+            #print("*** database('{}').cursor.open()".format(self.name))
+            self._cursor = self.tx.cursor()
+        return self._cursor
+
+    def drop(self):
+        sql, vals = self.engine.sql.drop_database(self.name)
+        self.tx.execute(sql, vals, single=True, cursor=self.cursor)
+
+    def create(self):
+        sql, vals = self.engine.sql.create_database(self.name)
+        self.tx.execute(sql, vals, single=True, cursor=self.cursor)
+
+    def exists(self):
+        sql, vals = self.sql.databases()
+        result = self.tx.execute(sql, vals, cursor=self.cursor)
+        return bool(self.name in [x[0] for x in result.as_tuple()])
+
+    @property
+    def tables(self):
+        sql, vals = self.sql.tables()
+        result = self.tx.execute(sql ,vals, cursor=self.cursor)
+        return ["%s.%s" % x for x in result.as_tuple()]
+
+    def reindex(self):
+        sql, vals = "REINDEX DATABASE {}".format(self.name), tuple()
+        self.tx.execute(sql, vals, cursor=self.cursor)

velocity/db/core/decorators.py

@@ -0,0 +1,81 @@
+from functools import wraps
+from velocity.db import exceptions
+
+def retry_on_dup_key(function):
+    @wraps(function)
+    def retry_decorator(self, *args, **kwds):
+        if hasattr(self, 'cursor'):
+            cursor = self.cursor
+        elif hasattr(self, 'table'):
+            cursor = self.table.cursor
+        sp = self.tx.create_savepoint(cursor=cursor)
+        while True:
+            try:
+                return function(self, *args, **kwds)
+            except exceptions.DbDuplicateKeyError:
+                self.tx.rollback_savepoint(sp, cursor=cursor)
+                continue
+    return retry_decorator
+
+def return_default(default=None):
+    def decorator(function):
+        function.default = default
+        @wraps(function)
+        def return_default(self, *args, **kwds):
+            if hasattr(self, 'cursor'):
+                cursor = self.cursor
+            elif hasattr(self, 'table'):
+                cursor = self.table.cursor
+            sp = self.tx.create_savepoint(cursor=cursor)
+            try:
+                result = function(self, *args, **kwds)
+            except (exceptions.DbApplicationError,
+                    exceptions.DbTableMissingError,
+                    exceptions.DbColumnMissingError,
+                    exceptions.DbTruncationError,
+                    StopIteration,
+                    exceptions.DbObjectExistsError):
+                self.tx.rollback_savepoint(sp, cursor=cursor)
+                return function.default
+            self.tx.release_savepoint(sp, cursor=cursor)
+            return result
+        return return_default
+    return decorator
+
+
+def create_missing(function):
+    @wraps(function)
+    def create_missing_decorator(self, *args, **kwds):
+        if hasattr(self, 'cursor'):
+            cursor = self.cursor
+        elif hasattr(self, 'table'):
+            cursor = self.table.cursor
+        sp = self.tx.create_savepoint(cursor=cursor)
+        try:
+            result = function(self, *args, **kwds)
+            self.tx.release_savepoint(sp, cursor=cursor)
+        except exceptions.DbColumnMissingError:
+            self.tx.rollback_savepoint(sp, cursor=cursor)
+            data = {}
+            if 'pk' in kwds:
+                data.update(kwds['pk'])
+            if 'data' in kwds:
+                data.update(kwds['data'])
+            for i in range(len(args)):
+                if args[i]:
+                    data.update(args[i])
+            self.alter(data)
+            result = function(self, *args, **kwds)
+        except exceptions.DbTableMissingError:
+            self.tx.rollback_savepoint(sp, cursor=cursor)
+            data = {}
+            if 'pk' in kwds:
+                data.update(kwds['pk'])
+            if 'data' in kwds:
+                data.update(kwds['data'])
+            for i in range(len(args)):
+                data.update(args[i])
+            self.create(data)
+            result = function(self, *args, **kwds)
+        return result
+    return create_missing_decorator