velocity-python 0.0.1__py3-none-any.whl

velocity/misc/conv.py

@@ -0,0 +1,420 @@
+import re
+import codecs
+import decimal
+from email.utils import parseaddr
+from datetime import datetime, date, time
+import pprint
+
+# oconv converts data to be displayed or rendered.
+class oconv(object):
+    @staticmethod
+    def none(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        if data == 'null':
+            return ''
+        return data
+
+    @staticmethod
+    def phone(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        if not data:
+            return data
+        data = re.search(r'\d{10}$', re.sub("[^0-9]", "", data)).group()
+        return "({}) {}-{}".format(data[:3],data[3:6],data[6:])
+
+
+    @staticmethod
+    def day_of_week(data, abbrev=False):
+        if isinstance(data, list):
+            new = []
+            for day in data:
+                new.append(oconv.day_of_week(day, abbrev=abbrev))
+            return ','.join(new)
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        if not data:
+            return data
+        if abbrev:
+            return {
+                1: 'Mon',
+                2: 'Tue',
+                3: 'Wed',
+                4: 'Thu',
+                5: 'Fri',
+                6: 'Sat',
+                7: 'Sun'
+            }[int(data)]
+        return {
+            1: 'Monday',
+            2: 'Tuesday',
+            3: 'Wednesday',
+            4: 'Thursday',
+            5: 'Friday',
+            6: 'Saturday',
+            7: 'Sunday'
+        }[int(data)]
+
+    @staticmethod
+    def date(*args, **kwds):
+        kwds.setdefault('fmt','%Y-%m-%d')
+        def _(param):
+            if isinstance(param,(datetime, date)):
+                return param.strftime( kwds['fmt'] )
+            else:
+                return param
+        if args and args[0]:
+            return _(args[0])
+        return _
+
+    @staticmethod
+    def time(*args, **kwds):
+        kwds.setdefault('fmt','%X')
+        def _(param):
+            if isinstance(param,(datetime, time)):
+                return param.strftime( kwds['fmt'] )
+            else:
+                return param
+        if args and args[0]:
+            return _(args[0])
+        return _
+
+    @staticmethod
+    def timestamp(*args, **kwds):
+        kwds.setdefault('fmt','%c')
+        def _(param):
+            if isinstance(param,(datetime)):
+                return param.strftime( kwds['fmt'] )
+            else:
+                return param
+        if args:
+            return _(args[0])
+        return _
+
+    @staticmethod
+    def email(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        return data.lower()
+
+    @staticmethod
+    def pointer(data):
+        try:
+            return int(data)
+        except:
+            return ''
+
+    @staticmethod
+    def rot13(data):
+        return codecs.decode(data,'rot13')
+
+    @staticmethod
+    def boolean(data):
+        if isinstance(data,str):
+            if data.lower() in ['false','','f','off','no']:
+                return False
+        return bool(data)
+
+    @staticmethod
+    def money(data):
+        if data in [None,'']:
+            return ''
+        data = re.sub("[^0-9\.-]", "", str(data))
+        return '${:,.2f}'.format(decimal.Decimal(data))
+
+    @staticmethod
+    def round(precision, data=None):
+        def function(data):
+            data = re.sub("[^0-9\.]", "", str(data))
+            if data == '':
+                return '0'
+            return '{:.{prec}f}'.format(decimal.Decimal(data), prec=precision)
+        if data == None:
+            return function
+        return function(data)
+
+    @staticmethod
+    def ein(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        if not data:
+            return data
+        data = re.search(r'\d{9}$', re.sub("[^0-9]", "", data)).group()
+        return "{}-{}".format(data[:2],data[2:])
+
+    @staticmethod
+    def list(data):
+        if data in (None,'None'):
+            return None
+        if isinstance(data, list):
+            return data
+        if isinstance(data, str):
+            if data[0] == '[':
+                return eval(data)
+        return [data]
+
+    @staticmethod
+    def title(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        return str(data).title()
+
+    @staticmethod
+    def lower(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        return str(data).lower()
+
+    @staticmethod
+    def upper(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        return str(data).upper()
+
+    @staticmethod
+    def padding(length, char):
+        def inner(data):
+            if data is None:
+                return ''
+            return str(data).rjust(length, char)
+        return inner
+
+    @staticmethod
+    def pprint(data):
+        try:
+            return pprint.pformat(eval(data))
+        except:
+            return data
+
+    @staticmethod
+    def string(data):
+        if data == None:
+            return ''
+        return str(data)
+
+# iconv converts data to be stored in the database.
+# The source is generally user input from html forms.
+class iconv(object):
+    @staticmethod
+    def none(data):
+        if data == '':
+            return None
+        if data == 'null':
+            return None
+        if data == '@NULL':
+            return None
+        return data
+
+    @staticmethod
+    def phone(data):
+        if data == 'None':
+            return None
+        if not data:
+            return data
+        return re.search(r'\d{10}$', re.sub("[^0-9]", "", data)).group()
+
+    @staticmethod
+    def day_of_week(data):
+        if not data:
+            return data
+        return {
+            'monday': 1,
+            'tuesday': 2,
+            'wednesday': 3,
+            'thursday': 4,
+            'friday': 5,
+            'saturday': 6,
+            'sunday': 7,
+            'mon': 1,
+            'tue': 2,
+            'wed': 3,
+            'thu': 4,
+            'fri': 5,
+            'sat': 6,
+            'sun': 7
+        }[data.lower()]
+
+    @staticmethod
+    def date(*args, **kwds):
+        kwds.setdefault('fmt', '%Y-%m-%d')
+        def _(param):
+            if isinstance(param,str):
+                return datetime.strptime(param, kwds['fmt']).date()
+            else:
+                return param
+        if args and args[0]:
+            return _(args[0])
+        return _
+
+    @staticmethod
+    def time(*args, **kwds):
+        kwds.setdefault('fmt','%X')
+        def _(param):
+            if isinstance(param, str):
+                return datetime.strptime(param, kwds['fmt']).time()
+            else:
+                return param
+        if args and args[0]:
+            return _(args[0])
+        return _
+
+    @staticmethod
+    def timestamp(*args, **kwds):
+        kwds.setdefault('fmt','%c')
+        def _(param):
+            if isinstance(param, str):
+                return datetime.strptime(param, kwds['fmt'])
+            else:
+                return param
+        if args and args[0]:
+            return _(args[0])
+        return _
+
+    @staticmethod
+    def email(data):
+        if not data:
+            return None
+        if data == 'None':
+            return None
+        data = data.strip().lower()
+        if '@' not in data:
+            raise Exception()
+        email = parseaddr(data)[1]
+        mailbox,domain = email.split('@')
+        if '.' in domain:
+            if len(domain.split('.')[1]) < 1:
+                raise Exception()
+        else:
+            raise Exception()
+        return data
+
+    @staticmethod
+    def integer(data):
+        return int(re.sub("[^0-9\.-]", "", str(data)))
+
+    @staticmethod
+    def boolean(data):
+        if isinstance(data,str):
+            if data.lower() in ['false','','f','off','no']:
+                return False
+        return bool(data)
+
+    @staticmethod
+    def rot13(data):
+        return codecs.encode(data,'rot13')
+
+    @staticmethod
+    def pointer(data):
+        if data == '@new': return data
+        if data == '': return None
+        if data == None: return None
+        if data == '@NULL': return None
+        return int(data)
+
+    @staticmethod
+    def money(data):
+        if data == 'None':
+            return None
+        if not data:
+            return data
+        return decimal.Decimal(re.sub("[^0-9\.-]", "", str(data)))
+
+    @staticmethod
+    def round(precision, data=None):
+        def function(data):
+            if data == 'None':
+                return None
+            if not data:
+                return data
+            if isinstance(data, str):
+                data = re.sub("[^0-9\.-]", "", data)
+            return decimal.Decimal(data).quantize(decimal.Decimal(10) ** -precision, rounding=decimal.ROUND_HALF_UP)
+        if data == None:
+            return function
+        return function(data)
+
+    @staticmethod
+    def decimal(data):
+        if data == 'None':
+            return None
+        if not data:
+            return data
+        return decimal.Decimal(re.sub("[^0-9\.-]", "", str(data)))
+
+    @staticmethod
+    def ein(data):
+        if data == 'None':
+            return None
+        if not data:
+            return data
+        return re.search(r'^\d{9}$', re.sub("[^0-9]", "", data)).group()
+
+    @staticmethod
+    def list(data):
+        if data in (None,'None'):
+            return None
+        if isinstance(data, str):
+            if data[0] == '[':
+                return data
+        if not isinstance(data, list):
+            data = [data]
+        return repr(data)
+
+    @staticmethod
+    def title(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        return str(data).title()
+
+    @staticmethod
+    def lower(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        return str(data).lower()
+
+
+    @staticmethod
+    def upper(data):
+        if data == None:
+            return ''
+        if data == 'None':
+            return ''
+        return str(data).upper()
+
+    @staticmethod
+    def padding(length, char):
+        def inner(data):
+            if data in [None,'None','']:
+                return None
+            return str(data).rjust(length, char)
+        return inner
+
+    @staticmethod
+    def string(data):
+        if data == '':
+            return None
+        return str(data)
+
+if __name__=='__main__':
+    print(iconv.money("$123.441.234c"))

velocity/misc/db.py

@@ -0,0 +1,85 @@
+import numbers
+import random
+import string
+from functools import wraps
+from velocity.db import exceptions
+
+#TBD implement or delete all this code. It is not used anywhere.
+def NotSupported(*args, **kwds):
+    raise Exception("Sorry, the driver for this database is not installed")
+
+
+def NOTNULL(x):
+    """ Helper function to filter out NULL values from keys/values functions """
+    return len(x) == 2 and x[1] is not None
+
+
+def pipe(func, primary, secondary, *args, **kwds):
+    with primary.transaction() as pri:
+        with secondary.transaction() as sec:
+            func(pri, sec, *args, **kwds)
+
+
+class join(object):
+    @classmethod
+    def _or(cls, *args, **kwargs):
+        return '(' + ' or '.join(cls._list(*args, **kwargs)) + ')'
+
+    @classmethod
+    def _and(cls, *args, **kwargs):
+        return '(' + ' and '.join(cls._list(*args, **kwargs)) + ')'
+
+    @classmethod
+    def _list(cls, *args, **kwargs):
+        vals = []
+        vals.extend(args)
+        for key,val in kwargs.items():
+            if isinstance(val, numbers.Number):
+                vals.append("{}={}".format(key,val))
+            else:
+                vals.append("{}='{}'".format(key,val))
+        return vals
+
+ 
+
+def return_default(default=None):
+    """
+    Decorator that sets a default value for a function.
+    If an exception is raised within the function, the decorator
+    catches the exception and returns the default value instead.
+    """
+    def decorator(f):
+        f.default = default
+        @wraps(f)
+        def return_default(self, *args, **kwds):
+            sp = self.tx.create_savepoint(cursor=self.table.cursor)
+            try:
+                result = f(self, *args, **kwds)
+            except (exceptions.DbApplicationError,
+                    exceptions.DbTableMissingError,
+                    exceptions.DbColumnMissingError,
+                    exceptions.DbTruncationError,
+                    StopIteration,
+                    exceptions.DbObjectExistsError):
+                self.tx.rollback_savepoint(sp, cursor=self.table.cursor)
+                return f.default
+            self.tx.release_savepoint(sp, cursor=self.table.cursor)
+            return result
+        return return_default
+    return decorator
+
+
+def randomword(length=None):
+    """
+    Generate a random word consisting of lowercase letters. This is used to generate random savepoint names.
+    The length of the word can be specified, otherwise a random length between 5 and 15 will be used. 
+    
+    Parameters:
+        length (int, optional): The length of the random word. If not provided, a random length between 5 and 15 will be used.
+    
+    Returns:
+        str: The randomly generated word.
+    """
+    if length is None:
+        length = random.randint(5,15)
+    return ''.join(random.choice(string.ascii_lowercase) for i in range(length))

velocity/misc/export.py

@@ -0,0 +1,147 @@
+import openpyxl
+from openpyxl.styles import NamedStyle, Font, Border, Side, Alignment
+from openpyxl.utils import get_column_letter
+from io import BytesIO
+import base64
+
+def extract(d, keys):
+    return [d[key] for key in keys]
+
+
+def autosize_columns(ws, fixed={}):
+    # Try to autosize the columns (doesn't always work due to dynamic
+    # content, font family and font size differences, etc.) There is no
+    # easy way to do this when buiding excel files.
+    for col in ws.columns:
+        max_length = 0
+        for cell in col:
+            try:  # Necessary to avoid error on empty cells
+                if len(str(cell.value)) > max_length:
+                    max_length = len(cell.value)
+            except:
+                pass
+        adjusted_width = (max_length + 2) * 1.2
+        try:
+            l = get_column_letter(col[0].column)
+            if l in fixed:
+                adjusted_width = fixed['l']
+            ws.column_dimensions[l].width = adjusted_width
+        except:
+            l = col[0].column
+            if l in fixed:
+                adjusted_width = fixed['l']
+            ws.column_dimensions[l].width = adjusted_width
+
+
+def create_spreadsheet(headers,
+                       rows,
+                       fileorbuffer,
+                       styles={},
+                       merge=[],
+                       formats={},
+                       named_styles=[],
+                       freeze_panes='A2',
+                       dimensions=None,
+                       auto_size=True):
+    wb = openpyxl.Workbook()
+    ws = wb.active
+
+    local_styles = {}
+
+    style = NamedStyle(name="col_header")
+    style.font = Font(bold=True)
+    style.border = Border(bottom=Side(style='medium', color="000000"))
+    local_styles[style.name] = style
+
+    style = NamedStyle(name="sum_total")
+    style.border = Border(bottom=Side(style='double', color="000000"))
+    local_styles[style.name] = style
+
+    style = NamedStyle(name="sub_total")
+    style.font = Font(bold=True)
+    style.border = Border(bottom=Side(style='thin', color="000000"))
+    local_styles[style.name] = style
+
+    style = NamedStyle(name="bold")
+    style.font = Font(bold=True)
+    local_styles[style.name] = style
+
+    style = NamedStyle(name="align_right")
+    style.font = Font(bold=True)
+    style.border = Border(top=Side(style='thin', color="000000"))
+    style.alignment = Alignment(horizontal="right", vertical="center")
+    local_styles[style.name] = style
+
+    style = NamedStyle(name="align_left")
+    style.font = Font(bold=True)
+    style.border = Border(top=Side(style='thin', color="000000"))
+    style.alignment = Alignment(horizontal="left", vertical="center")
+    local_styles[style.name] = style
+
+    style = NamedStyle(name="align_right_double")
+    style.font = Font(bold=True)
+    style.border = Border(top=Side(style='double', color="000000"))
+    style.alignment = Alignment(horizontal="right", vertical="center")
+    local_styles[style.name] = style
+
+    style = NamedStyle(name="align_left_double")
+    style.font = Font(bold=True)
+    style.border = Border(top=Side(style='double', color="000000"))
+    style.alignment = Alignment(horizontal="left", vertical="center")
+    local_styles[style.name] = style
+
+    for style in named_styles:
+        local_styles[style.name] = style
+
+    for style in local_styles.values():
+        wb.add_named_style(style)
+
+    ws.append(headers)
+
+    [ws.append(row) for row in rows]
+
+    if freeze_panes:
+        ws.freeze_panes = freeze_panes
+
+    if auto_size:
+        autosize_columns(ws)
+
+    if dimensions:
+        for key, val in dimensions.get('rows', {}).items():
+            ws.row_dimensions[key].height = val
+        for key, val in dimensions.get('columns', {}).items():
+            ws.column_dimensions[key].width = val
+
+    for cell, style in styles.items():
+        ws[cell].style = style
+
+    for cell_range in merge:
+        ws.merge_cells(cell_range)
+
+    for cell, format in formats.items():
+        ws[cell].number_format = format
+
+    wb.save(fileorbuffer)
+   
+
+def getDownloadableSpreadsheet(headers,
+                                rows,
+                                styles={},
+                                merge=[],
+                                formats={},
+                                named_styles=[],
+                                freeze_panes='A2',
+                                dimensions=None,
+                                auto_size=True):  
+    buffer = BytesIO() 
+    create_spreadsheet(headers,
+                        rows,
+                        buffer,
+                        styles,
+                        merge,
+                        formats,
+                        named_styles,
+                        freeze_panes,
+                        dimensions,
+                        auto_size)
+    return base64.b64encode(buffer.getvalue()).decode()