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

velocity/misc/conv/__init__.py

@@ -1,2 +1,2 @@
 from . import iconv
-from . import oconv
+from . import oconv

velocity/misc/conv/oconv.py

@@ -4,90 +4,92 @@ import decimal
 from datetime import datetime, date, time
 from pprint import pformat
 
+
 def none(data):
     if data == None:
-        return ''
-    if data == 'None':
-        return ''
-    if data == 'null':
-        return ''
+        return ""
+    if data == "None":
+        return ""
+    if data == "null":
+        return ""
     return data
 
 
 def phone(data):
     if data == None:
-        return ''
-    if data == 'None':
-        return ''
+        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:])
+    data = re.search(r"\d{10}$", re.sub("[^0-9]", "", data)).group()
+    return "({}) {}-{}".format(data[:3], data[3:6], data[6:])
+
 
 def day_of_week(data, abbrev=False):
     if isinstance(data, list):
         new = []
         for day in data:
             new.append(day_of_week(day, abbrev=abbrev))
-        return ','.join(new)
+        return ",".join(new)
     if data == None:
-        return ''
-    if data == 'None':
-        return ''
+        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: "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'
+        1: "Monday",
+        2: "Tuesday",
+        3: "Wednesday",
+        4: "Thursday",
+        5: "Friday",
+        6: "Saturday",
+        7: "Sunday",
     }[int(data)]
 
 
 def date(*args, **kwds):
-    kwds.setdefault('fmt','%Y-%m-%d')
+    kwds.setdefault("fmt", "%Y-%m-%d")
+
     def _(param):
-        if isinstance(param,(datetime, date)):
-            return param.strftime( kwds['fmt'] )
+        if isinstance(param, (datetime, date)):
+            return param.strftime(kwds["fmt"])
         else:
             return param
+
     if args and args[0]:
         return _(args[0])
     return _
 
 
 def time(*args, **kwds):
-    kwds.setdefault('fmt','%X')
+    kwds.setdefault("fmt", "%X")
+
     def _(param):
-        if isinstance(param,(datetime, time)):
-            return param.strftime( kwds['fmt'] )
+        if isinstance(param, (datetime, time)):
+            return param.strftime(kwds["fmt"])
         else:
             return param
+
     if args and args[0]:
         return _(args[0])
     return _
 
 
 def timestamp(*args, **kwds):
-    kwds.setdefault('fmt','%c')
+    kwds.setdefault("fmt", "%c")
+
     def _(param):
-        if isinstance(param,(datetime)):
-            return param.strftime( kwds['fmt'] )
+        if isinstance(param, (datetime)):
+            return param.strftime(kwds["fmt"])
         else:
             return param
+
     if args:
         return _(args[0])
     return _
@@ -95,9 +97,9 @@ def timestamp(*args, **kwds):
 
 def email(data):
     if data == None:
-        return ''
-    if data == 'None':
-        return ''
+        return ""
+    if data == "None":
+        return ""
     return data.lower()
 
 
@@ -105,33 +107,34 @@ def pointer(data):
     try:
         return int(data)
     except:
-        return ''
+        return ""
 
 
 def rot13(data):
-    return codecs.decode(data,'rot13')
+    return codecs.decode(data, "rot13")
 
 
 def boolean(data):
-    if isinstance(data,str):
-        if data.lower() in ['false','','f','off','no']:
+    if isinstance(data, str):
+        if data.lower() in ["false", "", "f", "off", "no"]:
             return False
     return bool(data)
 
 
 def money(data):
-    if data in [None,'']:
-        return ''
+    if data in [None, ""]:
+        return ""
     data = re.sub("[^0-9\.-]", "", str(data))
-    return '${:,.2f}'.format(decimal.Decimal(data))
+    return "${:,.2f}".format(decimal.Decimal(data))
 
 
 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 == "":
+            return "0"
+        return "{:.{prec}f}".format(decimal.Decimal(data), prec=precision)
+
     if data == None:
         return function
     return function(data)
@@ -139,55 +142,56 @@ def round(precision, data=None):
 
 def ein(data):
     if data == None:
-        return ''
-    if data == 'None':
-        return ''
+        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:])
+    data = re.search(r"\d{9}$", re.sub("[^0-9]", "", data)).group()
+    return "{}-{}".format(data[:2], data[2:])
 
 
 def list(data):
-    if data in (None,'None'):
+    if data in (None, "None"):
         return None
     if isinstance(data, list):
         return data
     if isinstance(data, str):
-        if data[0] == '[':
+        if data[0] == "[":
             return eval(data)
     return [data]
 
 
 def title(data):
     if data == None:
-        return ''
-    if data == 'None':
-        return ''
+        return ""
+    if data == "None":
+        return ""
     return str(data).title()
 
 
 def lower(data):
     if data == None:
-        return ''
-    if data == 'None':
-        return ''
+        return ""
+    if data == "None":
+        return ""
     return str(data).lower()
 
 
 def upper(data):
     if data == None:
-        return ''
-    if data == 'None':
-        return ''
+        return ""
+    if data == "None":
+        return ""
     return str(data).upper()
 
 
 def padding(length, char):
     def inner(data):
         if data is None:
-            return ''
+            return ""
         return str(data).rjust(length, char)
+
     return inner
 
 
@@ -200,5 +204,5 @@ def pprint(data):
 
 def string(data):
     if data == None:
-        return ''
+        return ""
     return str(data)

velocity/misc/db.py

@@ -4,13 +4,14 @@ import string
 from functools import wraps
 from velocity.db import exceptions
 
-#TBD implement or delete all this code. It is not used anywhere.
+
+# 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 """
+    """Helper function to filter out NULL values from keys/values functions"""
     return len(x) == 2 and x[1] is not None
 
 
@@ -23,24 +24,23 @@ def pipe(func, primary, secondary, *args, **kwds):
 class join(object):
     @classmethod
     def _or(cls, *args, **kwargs):
-        return '(' + ' or '.join(cls._list(*args, **kwargs)) + ')'
+        return "(" + " or ".join(cls._list(*args, **kwargs)) + ")"
 
     @classmethod
     def _and(cls, *args, **kwargs):
-        return '(' + ' and '.join(cls._list(*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():
+        for key, val in kwargs.items():
             if isinstance(val, numbers.Number):
-                vals.append("{}={}".format(key,val))
+                vals.append("{}={}".format(key, val))
             else:
-                vals.append("{}='{}'".format(key,val))
+                vals.append("{}='{}'".format(key, val))
         return vals
 
- 
 
 def return_default(default=None):
     """
@@ -48,38 +48,44 @@ def return_default(default=None):
     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):
+            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. 
-    
+    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))
+        length = random.randint(5, 15)
+    return "".join(random.choice(string.ascii_lowercase) for i in range(length))

velocity/misc/export.py

@@ -4,6 +4,7 @@ from openpyxl.utils import get_column_letter
 from io import BytesIO
 import base64
 
+
 def extract(d, keys):
     return [d[key] for key in keys]
 
@@ -24,25 +25,27 @@ def autosize_columns(ws, fixed={}):
         try:
             l = get_column_letter(col[0].column)
             if l in fixed:
-                adjusted_width = fixed['l']
+                adjusted_width = fixed["l"]
             ws.column_dimensions[l].width = adjusted_width
         except:
             l = col[0].column
             if l in fixed:
-                adjusted_width = fixed['l']
+                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):
+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
 
@@ -50,16 +53,16 @@ def create_spreadsheet(headers,
 
     style = NamedStyle(name="col_header")
     style.font = Font(bold=True)
-    style.border = Border(bottom=Side(style='medium', color="000000"))
+    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"))
+    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"))
+    style.border = Border(bottom=Side(style="thin", color="000000"))
     local_styles[style.name] = style
 
     style = NamedStyle(name="bold")
@@ -68,25 +71,25 @@ def create_spreadsheet(headers,
 
     style = NamedStyle(name="align_right")
     style.font = Font(bold=True)
-    style.border = Border(top=Side(style='thin', color="000000"))
+    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.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.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.border = Border(top=Side(style="double", color="000000"))
     style.alignment = Alignment(horizontal="left", vertical="center")
     local_styles[style.name] = style
 
@@ -107,9 +110,9 @@ def create_spreadsheet(headers,
         autosize_columns(ws)
 
     if dimensions:
-        for key, val in dimensions.get('rows', {}).items():
+        for key, val in dimensions.get("rows", {}).items():
             ws.row_dimensions[key].height = val
-        for key, val in dimensions.get('columns', {}).items():
+        for key, val in dimensions.get("columns", {}).items():
             ws.column_dimensions[key].width = val
 
     for cell, style in styles.items():
@@ -122,26 +125,30 @@ def create_spreadsheet(headers,
         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)
+
+
+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()

velocity/misc/format.py

@@ -5,7 +5,7 @@ from datetime import datetime, date, time, timedelta
 
 def gallons(data):
     if data is None:
-        return ''
+        return ""
     data = decimal.Decimal(data)
     return "{:.2f}".format(data)
     # return "{:1,.2f} gals".format(data)
@@ -13,7 +13,7 @@ def gallons(data):
 
 def gallons2liters(data):
     if data is None:
-        return ''
+        return ""
     data = decimal.Decimal(data) * decimal.Decimal(3.78541)
     return "{:.2f}".format(data)
     # return "{:1,.2f} liters".format(data)
@@ -21,7 +21,7 @@ def gallons2liters(data):
 
 def currency(data):
     if data is None:
-        return ''
+        return ""
     decimal.Decimal(data)
     return "{:.2f}".format(data)
     # return "${:1,.2f}".format(data)
@@ -42,17 +42,17 @@ def human_delta(tdelta):
     :return: The human formatted timedelta
     """
     d = dict(days=tdelta.days)
-    d['hrs'], rem = divmod(tdelta.seconds, 3600)
-    d['min'], d['sec'] = divmod(rem, 60)
+    d["hrs"], rem = divmod(tdelta.seconds, 3600)
+    d["min"], d["sec"] = divmod(rem, 60)
 
-    if d['min'] == 0:
-        fmt = '{sec} sec'
-    elif d['hrs'] == 0:
-        fmt = '{min} min {sec} sec'
-    elif d['days'] == 0:
-        fmt = '{hrs} hr(s) {min} min {sec} sec'
+    if d["min"] == 0:
+        fmt = "{sec} sec"
+    elif d["hrs"] == 0:
+        fmt = "{min} min {sec} sec"
+    elif d["days"] == 0:
+        fmt = "{hrs} hr(s) {min} min {sec} sec"
     else:
-        fmt = '{days} day(s) {hrs} hr(s) {min} min {sec} sec'
+        fmt = "{days} day(s) {hrs} hr(s) {min} min {sec} sec"
 
     return fmt.format(**d)
 
@@ -60,7 +60,7 @@ def human_delta(tdelta):
 def to_json(o, datefmt="%Y-%m-%d", timefmt="%H:%M:%S"):
     class JsonEncoder(json.JSONEncoder):
         def default(self, o):
-            if hasattr(o, 'to_json'):
+            if hasattr(o, "to_json"):
                 return o.to_json()
             elif o is None:
                 return 0
@@ -78,4 +78,5 @@ def to_json(o, datefmt="%Y-%m-%d", timefmt="%H:%M:%S"):
                 return super(JsonEncoder, self).default(o)
             except:
                 return str(o)
+
     return json.dumps(o, cls=JsonEncoder)

velocity/misc/mail.py

@@ -3,26 +3,32 @@ from email.parser import Parser as EmailParser
 from io import BytesIO
 import mimetypes, hashlib
 
+
 class NotSupportedMailFormat(Exception):
     pass
 
+
 def get_full_emails(addresses):
     results = []
     for a in addresses:
         if a.name:
-            results.append(f"{a.name.decode('utf-8')} <{a.mailbox.decode('utf-8')}@{a.host.decode('utf-8')}>")
+            results.append(
+                f"{a.name.decode('utf-8')} <{a.mailbox.decode('utf-8')}@{a.host.decode('utf-8')}>"
+            )
         else:
             results.append(f"{a.mailbox.decode('utf-8')}@{a.host.decode('utf-8')}")
     return results
 
+
 def get_address_only(addresses):
     results = []
     for a in addresses:
         results.append(f"{a.mailbox.decode('utf-8')}@{a.host.decode('utf-8')}")
     return results
 
+
 def parse_attachment(part):
-    content_disposition = part.get('Content-Disposition')
+    content_disposition = part.get("Content-Disposition")
     if content_disposition:
         dispositions = content_disposition.strip().split(";")
         if content_disposition and dispositions[0].lower() == "attachment":
@@ -43,6 +49,7 @@ def parse_attachment(part):
 
     return None
 
+
 def parse(content):
     body = None
     html = None
@@ -61,7 +68,7 @@ def parse(content):
             html += part.get_payload(decode=True)
 
     return {
-        'body' : body,
-        'html' : html,
-        'attachments': attachments,
+        "body": body,
+        "html": html,
+        "attachments": attachments,
     }