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

velocity/misc/conv/oconv.py

@@ -3,46 +3,31 @@ import codecs
 import decimal
 from datetime import datetime, date, time
 from pprint import pformat
+from typing import Optional, Union, List, Callable
 
+# Convert SQL data to JS format for display
 
-def none(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    if data == "null":
-        return ""
-    return data
 
+def none(data: Optional[str]) -> str:
+    """Converts various 'null' representations to an empty string."""
+    return "" if data in (None, "None", "null", "@NULL") else data
 
-def phone(data):
-    if data == None:
-        return ""
-    if data == "None":
+
+def phone(data: Optional[str]) -> str:
+    """Formats a 10-digit phone number as (XXX) XXX-XXXX or returns an empty string if invalid."""
+    if data in (None, "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:])
+    digits = re.sub(r"[^0-9]", "", data)
+    match = re.search(r"\d{10}$", digits)
+    if match:
+        num = match.group()
+        return f"({num[:3]}) {num[3:6]}-{num[6:]}"
+    return ""
 
 
-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)
-    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 {
+def day_of_week(data: Union[int, str, List], abbrev: bool = False) -> str:
+    """Converts a day number (1-7) to a day name, abbreviated if specified. Supports lists."""
+    days_full = {
         1: "Monday",
         2: "Tuesday",
         3: "Wednesday",
@@ -50,159 +35,136 @@ def day_of_week(data, abbrev=False):
         5: "Friday",
         6: "Saturday",
         7: "Sunday",
-    }[int(data)]
-
-
-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 _
+    }
+    days_abbrev = {1: "Mon", 2: "Tue", 3: "Wed", 4: "Thu", 5: "Fri", 6: "Sat", 7: "Sun"}
+    days = days_abbrev if abbrev else days_full
 
+    if isinstance(data, list):
+        return ",".join(day_of_week(day, abbrev) for day in data if day in days)
 
-def time(*args, **kwds):
-    kwds.setdefault("fmt", "%X")
+    try:
+        return days[int(data)]
+    except (ValueError, KeyError, TypeError):
+        return ""
 
-    def _(param):
-        if isinstance(param, (datetime, time)):
-            return param.strftime(kwds["fmt"])
-        else:
-            return param
 
-    if args and args[0]:
-        return _(args[0])
-    return _
+def date(data: Union[datetime, date, str], fmt: str = "%Y-%m-%d") -> str:
+    """Formats a date object as a string according to the specified format."""
+    return data.strftime(fmt) if isinstance(data, (datetime, date)) else str(data)
 
 
-def timestamp(*args, **kwds):
-    kwds.setdefault("fmt", "%c")
+def time(data: Union[datetime, time, str], fmt: str = "%X") -> str:
+    """Formats a time object as a string according to the specified format."""
+    return data.strftime(fmt) if isinstance(data, (datetime, time)) else str(data)
 
-    def _(param):
-        if isinstance(param, (datetime)):
-            return param.strftime(kwds["fmt"])
-        else:
-            return param
 
-    if args:
-        return _(args[0])
-    return _
+def timestamp(data: Union[datetime, str], fmt: str = "%c") -> str:
+    """Formats a datetime object as a string according to the specified format."""
+    return data.strftime(fmt) if isinstance(data, datetime) else str(data)
 
 
-def email(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    return data.lower()
+def email(data: Optional[str]) -> str:
+    """Returns a lowercase email address or an empty string if invalid."""
+    return "" if data in (None, "None") else data.lower()
 
 
-def pointer(data):
+def pointer(data: Union[str, int]) -> Union[int, str]:
+    """Converts a string to an integer, or returns an empty string if conversion fails."""
     try:
         return int(data)
-    except:
+    except (ValueError, TypeError):
         return ""
 
 
-def rot13(data):
+def rot13(data: str) -> str:
+    """Encodes a string using ROT13."""
     return codecs.decode(data, "rot13")
 
 
-def boolean(data):
-    if isinstance(data, str):
-        if data.lower() in ["false", "", "f", "off", "no"]:
-            return False
+def boolean(data: Union[str, bool]) -> bool:
+    """Converts various representations to a boolean."""
+    if isinstance(data, str) and data.lower() in ["false", "", "f", "off", "no"]:
+        return False
     return bool(data)
 
 
-def money(data):
+def money(data: str) -> str:
+    """Formats a numeric string as currency."""
     if data in [None, ""]:
         return ""
-    data = re.sub("[^0-9\.-]", "", str(data))
-    return "${:,.2f}".format(decimal.Decimal(data))
+    cleaned_data = re.sub(r"[^0-9\.-]", "", str(data))
+    return f"${decimal.Decimal(cleaned_data):,.2f}"
 
 
-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)
+def round_to(
+    precision: int, data: Optional[Union[str, float, decimal.Decimal]] = None
+) -> Union[Callable, str]:
+    """Rounds a number to the specified precision."""
 
-    if data == None:
-        return function
-    return function(data)
+    def function(value):
+        cleaned_value = re.sub(r"[^0-9\.-]", "", str(value))
+        return (
+            f"{decimal.Decimal(cleaned_value):.{precision}f}" if cleaned_value else "0"
+        )
 
+    return function if data is None else function(data)
 
-def ein(data):
-    if data == None:
-        return ""
-    if data == "None":
+
+def ein(data: str) -> str:
+    """Formats a 9-digit EIN as XX-XXXXXXX or returns an empty string if invalid."""
+    if data in (None, "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:])
+    cleaned_data = re.sub(r"[^0-9]", "", data)
+    match = re.fullmatch(r"\d{9}", cleaned_data)
+    return f"{cleaned_data[:2]}-{cleaned_data[2:]}" if match else ""
 
 
-def list(data):
+def to_list(data: Union[str, List]) -> Optional[List]:
+    """Converts a single element or JSON-like list string to a list."""
     if data in (None, "None"):
         return None
     if isinstance(data, list):
         return data
-    if isinstance(data, str):
-        if data[0] == "[":
-            return eval(data)
+    if isinstance(data, str) and data.startswith("["):
+        try:
+            return eval(data)  # Be cautious with eval; only use if data is trusted
+        except (SyntaxError, NameError):
+            return None
     return [data]
 
 
-def title(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    return str(data).title()
+def title(data: Optional[str]) -> str:
+    """Converts a string to title case."""
+    return "" if data in (None, "None") else str(data).title()
 
 
-def lower(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    return str(data).lower()
+def lower(data: Optional[str]) -> str:
+    """Converts a string to lowercase."""
+    return "" if data in (None, "None") else str(data).lower()
 
 
-def upper(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    return str(data).upper()
+def upper(data: Optional[str]) -> str:
+    """Converts a string to uppercase."""
+    return "" if data in (None, "None") else str(data).upper()
+
 
+def padding(length: int, char: str) -> Callable[[str], str]:
+    """Returns a function that pads a string to the specified length with the given character."""
 
-def padding(length, char):
-    def inner(data):
-        if data is None:
-            return ""
-        return str(data).rjust(length, char)
+    def inner(data: str) -> str:
+        return str(data).rjust(length, char) if data not in (None, "None", "") else ""
 
     return inner
 
 
-def pprint(data):
+def pprint(data: str) -> str:
+    """Pretty-prints a JSON-like string representation of data."""
     try:
         return pformat(eval(data))
-    except:
+    except (SyntaxError, NameError):
         return data
 
 
-def string(data):
-    if data == None:
-        return ""
-    return str(data)
+def string(data: Optional[str]) -> str:
+    """Converts a None value to an empty string; otherwise returns the string itself."""
+    return "" if data is None else str(data)

velocity/misc/export.py

@@ -1,143 +1,146 @@
+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
+        col_letter = get_column_letter(col[0].column)
+        ws.column_dimensions[col_letter].width = fixed.get(col_letter, adjusted_width)
 
 
 def create_spreadsheet(
-    headers,
-    rows,
+    headers: List[str],
+    rows: List[List],
     fileorbuffer,
-    styles={},
-    merge=[],
-    formats={},
-    named_styles=[],
-    freeze_panes="A2",
-    dimensions=None,
-    auto_size=True,
+    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():
             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
-
+    # 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,
-):
+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,