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

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

@@ -1,147 +1,157 @@
+import decimal
+import json
+from datetime import datetime, date, time, timedelta
+from typing import Union, List, Dict
+from io import BytesIO
+import base64
 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 extract(d: dict, keys: List[str]) -> List:
+    """Extract values from a dictionary based on a list of keys."""
+    return [d.get(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.
+def autosize_columns(ws, fixed: Dict[str, float] = {}):
+    """Autosize columns in the worksheet based on content length."""
     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
+            try:
+                if cell.value and len(str(cell.value)) > max_length:
+                    max_length = len(str(cell.value))
+            except Exception:
+                continue
         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):
+        col_letter = get_column_letter(col[0].column)
+        ws.column_dimensions[col_letter].width = fixed.get(col_letter, adjusted_width)
+
+
+def create_spreadsheet(
+    headers: List[str],
+    rows: List[List],
+    fileorbuffer,
+    styles: Dict[str, str] = {},
+    merge: List[str] = [],
+    formats: Dict[str, str] = {},
+    named_styles: List[NamedStyle] = [],
+    freeze_panes: str = "A2",
+    dimensions: dict = None,
+    auto_size: bool = True,
+):
+    """Create an Excel spreadsheet with specified headers, rows, and styles."""
     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
-
+    # Define default named styles
+    def get_named_styles():
+        named_styles = {
+            "col_header": NamedStyle(
+                name="col_header",
+                font=Font(bold=True),
+                border=Border(bottom=Side(style="medium", color="000000")),
+            ),
+            "sum_total": NamedStyle(
+                name="sum_total",
+                border=Border(bottom=Side(style="double", color="000000")),
+            ),
+            "sub_total": NamedStyle(
+                name="sub_total",
+                font=Font(bold=True),
+                border=Border(bottom=Side(style="thin", color="000000")),
+            ),
+            "bold": NamedStyle(name="bold", font=Font(bold=True)),
+            "align_right": NamedStyle(
+                name="align_right",
+                font=Font(bold=True),
+                border=Border(top=Side(style="thin", color="000000")),
+                alignment=Alignment(horizontal="right", vertical="center"),
+            ),
+            "align_left": NamedStyle(
+                name="align_left",
+                font=Font(bold=True),
+                border=Border(top=Side(style="thin", color="000000")),
+                alignment=Alignment(horizontal="left", vertical="center"),
+            ),
+            "align_right_double": NamedStyle(
+                name="align_right_double",
+                font=Font(bold=True),
+                border=Border(top=Side(style="double", color="000000")),
+                alignment=Alignment(horizontal="right", vertical="center"),
+            ),
+            "align_left_double": NamedStyle(
+                name="align_left_double",
+                font=Font(bold=True),
+                border=Border(top=Side(style="double", color="000000")),
+                alignment=Alignment(horizontal="left", vertical="center"),
+            ),
+        }
+        return named_styles
+
+    # Add default and user-defined styles
+    local_styles = get_named_styles()
     for style in named_styles:
         local_styles[style.name] = style
-
     for style in local_styles.values():
         wb.add_named_style(style)
 
+    # Add headers and rows
     ws.append(headers)
+    for row in rows:
+        ws.append(row)
 
-    [ws.append(row) for row in rows]
-
-    if freeze_panes:
-        ws.freeze_panes = freeze_panes
+    # Set freeze panes
+    ws.freeze_panes = freeze_panes
 
+    # Auto-size columns if enabled
     if auto_size:
-        autosize_columns(ws)
+        autosize_columns(ws, fixed={})
 
+    # Set row and column dimensions if provided
     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():
-        ws[cell].style = style
-
+    # Apply cell styles, merges, and formats
+    for cell, style_name in styles.items():
+        if style_name in local_styles:
+            ws[cell].style = local_styles[style_name]
     for cell_range in merge:
         ws.merge_cells(cell_range)
+    for cell, format_code in formats.items():
+        ws[cell].number_format = format_code
 
-    for cell, format in formats.items():
-        ws[cell].number_format = format
-
+    # Save workbook to the provided file or buffer
     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 get_downloadable_spreadsheet(
+    headers: List[str],
+    rows: List[List],
+    styles: Dict[str, str] = {},
+    merge: List[str] = [],
+    formats: Dict[str, str] = {},
+    named_styles: List[NamedStyle] = [],
+    freeze_panes: str = "A2",
+    dimensions: dict = None,
+    auto_size: bool = True,
+) -> str:
+    """Generate a downloadable spreadsheet encoded in base64."""
+    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

@@ -1,81 +1,79 @@
 import decimal
 import json
 from datetime import datetime, date, time, timedelta
+from typing import Union
 
 
-def gallons(data):
+def gallons(data: Union[None, str, float, decimal.Decimal]) -> str:
+    """Converts a value to a string formatted in gallons with two decimal places."""
     if data is None:
-        return ''
-    data = decimal.Decimal(data)
-    return "{:.2f}".format(data)
-    # return "{:1,.2f} gals".format(data)
+        return ""
+    try:
+        data = decimal.Decimal(data)
+        return f"{data:.2f}"
+    except (decimal.InvalidOperation, ValueError, TypeError):
+        return ""  # Return an empty string for invalid input
 
 
-def gallons2liters(data):
+def gallons2liters(data: Union[None, str, float, decimal.Decimal]) -> str:
+    """Converts gallons to liters and formats with two decimal places."""
     if data is None:
-        return ''
-    data = decimal.Decimal(data) * decimal.Decimal(3.78541)
-    return "{:.2f}".format(data)
-    # return "{:1,.2f} liters".format(data)
+        return ""
+    try:
+        data = decimal.Decimal(data) * decimal.Decimal("3.78541")
+        return f"{data:.2f}"
+    except (decimal.InvalidOperation, ValueError, TypeError):
+        return ""
 
 
-def currency(data):
+def currency(data: Union[None, str, float, decimal.Decimal]) -> str:
+    """Formats a value as currency with two decimal places."""
     if data is None:
-        return ''
-    decimal.Decimal(data)
-    return "{:.2f}".format(data)
-    # return "${:1,.2f}".format(data)
+        return ""
+    try:
+        data = decimal.Decimal(data)
+        return f"{data:.2f}"
+    except (decimal.InvalidOperation, ValueError, TypeError):
+        return ""
 
 
-def human_delta(tdelta):
-    """
-    Takes a timedelta object and formats it for humans.
-    Usage:
-        # 149 day(s) 8 hr(s) 36 min 19 sec
-        print(human_delta(datetime(2014, 3, 30) - datetime.now()))
-    Example Results:
-        23 sec
-        12 min 45 sec
-        1 hr(s) 11 min 2 sec
-        3 day(s) 13 hr(s) 56 min 34 sec
-    :param tdelta: The timedelta object.
-    :return: The human formatted timedelta
-    """
-    d = dict(days=tdelta.days)
-    d['hrs'], rem = divmod(tdelta.seconds, 3600)
-    d['min'], d['sec'] = divmod(rem, 60)
+def human_delta(tdelta: timedelta) -> str:
+    """Formats a timedelta object into a human-readable format."""
+    d = {"days": tdelta.days, "hrs": 0, "min": 0, "sec": 0}
+    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)
 
 
-def to_json(o, datefmt="%Y-%m-%d", timefmt="%H:%M:%S"):
+def to_json(o, datefmt: str = "%Y-%m-%d", timefmt: str = "%H:%M:%S") -> str:
+    """Serializes an object to JSON, handling special types like Decimal and datetime."""
+
     class JsonEncoder(json.JSONEncoder):
-        def default(self, o):
-            if hasattr(o, 'to_json'):
-                return o.to_json()
-            elif o is None:
-                return 0
-            elif isinstance(o, decimal.Decimal):
-                return float(o)
-            elif isinstance(o, date):
-                return o.strftime(datefmt)
-            elif isinstance(o, datetime):
-                return o.strftime("{} {}".format(datefmt, timefmt))
-            elif isinstance(o, time):
-                return o.strftime(timefmt)
-            elif isinstance(o, timedelta):
-                return human_delta(o)
-            try:
-                return super(JsonEncoder, self).default(o)
-            except:
-                return str(o)
+        def default(self, obj):
+            if hasattr(obj, "to_json"):
+                return obj.to_json()
+            elif obj is None:
+                return None
+            elif isinstance(obj, decimal.Decimal):
+                return float(obj)
+            elif isinstance(obj, date):
+                return obj.strftime(datefmt)
+            elif isinstance(obj, datetime):
+                return obj.strftime(f"{datefmt} {timefmt}")
+            elif isinstance(obj, time):
+                return obj.strftime(timefmt)
+            elif isinstance(obj, timedelta):
+                return human_delta(obj)
+            return super().default(obj)
+
     return json.dumps(o, cls=JsonEncoder)

velocity/misc/mail.py

@@ -1,67 +1,78 @@
 #!/usr/local/bin/python
 from email.parser import Parser as EmailParser
-from io import BytesIO
-import mimetypes, hashlib
+from email.message import Message
+from typing import List, Optional
+import mimetypes
+import hashlib
+
 
 class NotSupportedMailFormat(Exception):
+    """Exception raised for unsupported mail formats."""
+
     pass
 
-def get_full_emails(addresses):
+
+class Attachment:
+    """Represents an email attachment."""
+
+    def __init__(self, name: str, data: bytes):
+        self.name = name
+        self.data = data
+        self.ctype = mimetypes.guess_type(name)[0] or "application/octet-stream"
+        self.size = len(data)
+        self.hash = hashlib.sha1(data).hexdigest()
+
+
+def get_full_emails(addresses: List) -> List[str]:
+    """Generates a list of formatted email addresses with names."""
     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')}>")
+        mailbox = a.mailbox.decode("utf-8")
+        host = a.host.decode("utf-8")
+        name = a.name.decode("utf-8") if a.name else None
+        if name:
+            results.append(f"{name} <{mailbox}@{host}>")
         else:
-            results.append(f"{a.mailbox.decode('utf-8')}@{a.host.decode('utf-8')}")
+            results.append(f"{mailbox}@{host}")
     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')
+def get_address_only(addresses: List) -> List[str]:
+    """Generates a list of email addresses without names."""
+    return [f"{a.mailbox.decode('utf-8')}@{a.host.decode('utf-8')}" for a in addresses]
+
+
+def parse_attachment(part: Message) -> Optional[Attachment]:
+    """Parses an attachment from a message part if present."""
+    content_disposition = part.get("Content-Disposition")
     if content_disposition:
         dispositions = content_disposition.strip().split(";")
-        if content_disposition and dispositions[0].lower() == "attachment":
+        if dispositions[0].lower() == "attachment":
             name = part.get_filename()
-            if not name:
-                return None
             data = part.get_payload(decode=True)
-            if not data:
-                return None
-            attachment = Object()
-            attachment.data = data
-            attachment.ctype = mimetypes.guess_type(name)[0]
-            attachment.size = len(data)
-            attachment.name = name
-            attachment.hash = hashlib.sha1(data).hexdigest()
-
-            return attachment
-
+            if name and data:
+                return Attachment(name=name, data=data)
     return None
 
-def parse(content):
-    body = None
-    html = None
+
+def parse(content: str) -> dict:
+    """Parses the email content and extracts plain text, HTML, and attachments."""
+    body = bytearray()
+    html = bytearray()
     attachments = []
-    for part in EmailParser().parsestr(content).walk():
+
+    message = EmailParser().parsestr(content)
+    for part in message.walk():
         attachment = parse_attachment(part)
         if attachment:
             attachments.append(attachment)
         elif part.get_content_type() == "text/plain":
-            if body is None:
-                body = bytes()
-            body += part.get_payload(decode=True)
+            body.extend(part.get_payload(decode=True) or b"")
         elif part.get_content_type() == "text/html":
-            if html is None:
-                html = bytes()
-            html += part.get_payload(decode=True)
+            html.extend(part.get_payload(decode=True) or b"")
 
     return {
-        'body' : body,
-        'html' : html,
-        'attachments': attachments,
+        "body": body.decode("utf-8") if body else None,
+        "html": html.decode("utf-8") if html else None,
+        "attachments": attachments,
     }