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

velocity/misc/conv/iconv.py

@@ -1,32 +1,33 @@
+# iconv.py
 import re
 import codecs
-import decimal as _decimal
+from decimal import Decimal, ROUND_HALF_UP
 from email.utils import parseaddr
 from datetime import datetime
+from typing import Optional, Union, Callable
 
+# Convert data to SQL format for storage
 
-def none(data):
-    if data == "":
-        return None
-    if data == "null":
-        return None
-    if data == "@NULL":
-        return None
-    return data
+
+def none(data: str) -> Optional[str]:
+    """Converts various 'null' representations to None."""
+    return None if data in ("", "null", "None", "@NULL") else data
 
 
-def phone(data):
-    if data == "None":
+def phone(data: str) -> Optional[str]:
+    """Extracts a 10-digit phone number or returns None if invalid."""
+    if data in ("None", None):
         return None
-    if not data:
-        return data
-    return re.search(r"\d{10}$", re.sub("[^0-9]", "", data)).group()
+    cleaned_data = re.sub(r"[^0-9]", "", data)
+    match = re.search(r"\d{10}$", cleaned_data)
+    return match.group() if match else None
 
 
-def day_of_week(data):
+def day_of_week(data: str) -> Optional[int]:
+    """Converts day of the week to an integer representation."""
     if not data:
-        return data
-    return {
+        return None
+    days = {
         "monday": 1,
         "tuesday": 2,
         "wednesday": 3,
@@ -41,174 +42,141 @@ def day_of_week(data):
         "fri": 5,
         "sat": 6,
         "sun": 7,
-    }[data.lower()]
-
+    }
+    return days.get(data.lower())
 
-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 _
+def date(data: str, fmt: str = "%Y-%m-%d") -> Optional[datetime.date]:
+    """Parses a date string into a date object using the specified format."""
+    try:
+        return datetime.strptime(data, fmt).date()
+    except (ValueError, TypeError):
+        return None
 
 
-def time(*args, **kwds):
-    kwds.setdefault("fmt", "%X")
+def time(data: str, fmt: str = "%X") -> Optional[datetime.time]:
+    """Parses a time string into a time object using the specified format."""
+    try:
+        return datetime.strptime(data, fmt).time()
+    except (ValueError, TypeError):
+        return None
 
-    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 _
+def timestamp(data: str, fmt: str = "%c") -> Optional[datetime]:
+    """Parses a timestamp string into a datetime object using the specified format."""
+    try:
+        return datetime.strptime(data, fmt)
+    except (ValueError, TypeError):
+        return None
 
 
-def timestamp(*args, **kwds):
-    kwds.setdefault("fmt", "%c")
+def email(data: str) -> Optional[str]:
+    """Validates and returns an email address if properly formatted."""
+    if not data or data.lower() == "none":
+        return None
+    data = data.strip().lower()
+    email_address = parseaddr(data)[1]
+    if "@" in email_address and "." in email_address.split("@")[1]:
+        return email_address
+    raise ValueError("Invalid email format")
 
-    def _(param):
-        if isinstance(param, str):
-            return datetime.strptime(param, kwds["fmt"])
-        else:
-            return param
 
-    if args and args[0]:
-        return _(args[0])
-    return _
+def integer(data: str) -> int:
+    """Converts a string to an integer, removing non-numeric characters."""
+    cleaned_data = re.sub(r"[^0-9\.-]", "", data)
+    try:
+        return int(float(cleaned_data))
+    except ValueError:
+        raise ValueError(f"Cannot convert {data} to integer.")
 
 
-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
-
-
-def integer(data):
-    return int(re.sub("[^0-9\.-]", "", str(data)))
-
-
-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 string representations to a boolean."""
+    if isinstance(data, str) and data.lower() in ["false", "", "f", "off", "no"]:
+        return False
     return bool(data)
 
 
-def rot13(data):
+def rot13(data: str) -> str:
+    """Encodes a string using ROT13."""
     return codecs.encode(data, "rot13")
 
 
-def pointer(data):
-    if data == "@new":
-        return data
-    if data == "":
-        return None
-    if data == None:
-        return None
-    if data == "@NULL":
+def pointer(data: Union[str, None]) -> Optional[int]:
+    """Converts a pointer to an integer, or returns None for null values."""
+    if data in ("@new", "", "@NULL", None):
         return None
     return int(data)
 
 
-def money(data):
-    if data == "None":
+def money(data: str) -> Optional[Decimal]:
+    """Converts a monetary string to a Decimal, removing non-numeric characters."""
+    if data in ("None", None):
         return None
-    if not data:
-        return data
-    return _decimal.Decimal(re.sub("[^0-9\.-]", "", str(data)))
+    return Decimal(re.sub(r"[^0-9\.-]", "", data))
+
 
+def round_to(
+    precision: int, data: Optional[Union[str, float, Decimal]] = None
+) -> Union[Decimal, Callable[[Union[str, float, Decimal]], Decimal]]:
+    """Rounds a number to a specified precision."""
 
-def round(precision, data=None):
-    def function(data):
-        if data == "None":
+    def function(value):
+        if value in ("None", 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 isinstance(value, str):
+            value = re.sub(r"[^0-9\.-]", "", value)
+        return Decimal(value).quantize(
+            Decimal(10) ** -precision, rounding=ROUND_HALF_UP
         )
 
-    if data == None:
-        return function
-    return function(data)
+    return function(data) if data is not None else function
 
 
-def decimal(data):
-    if data == "None":
+def decimal(data: str) -> Optional[Decimal]:
+    """Converts a numeric string to a Decimal, removing non-numeric characters."""
+    if data in ("None", None):
         return None
-    if not data:
-        return data
-    return _decimal.Decimal(re.sub("[^0-9\.-]", "", str(data)))
+    return Decimal(re.sub(r"[^0-9\.-]", "", data))
 
 
-def ein(data):
-    if data == "None":
+def ein(data: str) -> Optional[str]:
+    """Validates and returns a 9-digit EIN, or None if invalid."""
+    if data in ("None", None):
         return None
-    if not data:
-        return data
-    return re.search(r"^\d{9}$", re.sub("[^0-9]", "", data)).group()
+    cleaned_data = re.sub(r"[^0-9]", "", data)
+    match = re.fullmatch(r"\d{9}", cleaned_data)
+    return match.group() if match else None
 
 
-def list(data):
+def to_list(data: Union[str, list]) -> Optional[list]:
+    """Converts a string or single element into a list representation."""
     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)
+    if isinstance(data, str) and data.startswith("["):
+        return eval(data)  # Assuming the input string is a list string
+    return [data] if not isinstance(data, list) else data
+
 
+def title(data: str) -> str:
+    """Converts a string to title case."""
+    return "" if data in (None, "None") else str(data).title()
 
-def title(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    return str(data).title()
 
+def lower(data: str) -> str:
+    """Converts a string to lowercase."""
+    return "" if data in (None, "None") else str(data).lower()
 
-def lower(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    return str(data).lower()
 
+def upper(data: str) -> str:
+    """Converts a string to uppercase."""
+    return "" if data in (None, "None") else str(data).upper()
 
-def upper(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    return str(data).upper()
 
+def padding(length: int, char: str = " ") -> Callable[[str], Optional[str]]:
+    """Pads a string to the specified length with a given character."""
 
-def padding(length, char):
-    def inner(data):
+    def inner(data: str) -> Optional[str]:
         if data in [None, "None", ""]:
             return None
         return str(data).rjust(length, char)
@@ -216,7 +184,6 @@ def padding(length, char):
     return inner
 
 
-def string(data):
-    if data == "":
-        return None
-    return str(data)
+def string(data: str) -> Optional[str]:
+    """Converts an empty string to None, otherwise returns the string itself."""
+    return None if data == "" else str(data)

velocity/misc/conv/oconv.py

@@ -1,48 +1,35 @@
+# oconv.py
 import re
 import codecs
 import decimal
-from datetime import datetime, date, time
+import datetime
 from pprint import pformat
+from typing import Optional, Union, List, Callable
+import ast
 
+# 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 +37,164 @@ def day_of_week(data, abbrev=False):
         5: "Friday",
         6: "Saturday",
         7: "Sunday",
-    }[int(data)]
+    }
+    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 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 _
+    try:
+        return days[int(data)]
+    except (ValueError, KeyError, TypeError):
+        return ""
 
 
-def time(*args, **kwds):
-    kwds.setdefault("fmt", "%X")
+def date(
+    data: Union[datetime.datetime, 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.datetime, datetime.date))
+        else str(data)
+    )
 
-    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 time(data: Union[datetime.datetime, 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.datetime, datetime.time))
+        else str(data)
+    )
 
 
-def timestamp(*args, **kwds):
-    kwds.setdefault("fmt", "%c")
+def timestamp(data: Union[datetime.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.datetime) else str(data)
 
-    def _(param):
-        if isinstance(param, (datetime)):
-            return param.strftime(kwds["fmt"])
-        else:
-            return param
 
-    if args:
-        return _(args[0])
-    return _
+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 email(data):
-    if data == None:
-        return ""
-    if data == "None":
-        return ""
-    return 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: Union[str, float, int, decimal.Decimal]) -> str:
+    """Formats a numeric value as currency."""
     if data in [None, ""]:
         return ""
-    data = re.sub("[^0-9\.-]", "", str(data))
-    return "${:,.2f}".format(decimal.Decimal(data))
+    try:
+        amount = decimal.Decimal(str(data))
+        return f"${amount:,.2f}"
+    except (decimal.InvalidOperation, ValueError):
+        return ""
+
 
+def round_to(
+    precision: int, data: Optional[Union[str, float, decimal.Decimal]] = None
+) -> Union[Callable[[Union[str, float, decimal.Decimal]], str], str]:
+    """Rounds a number to the specified precision."""
 
-def round(precision, data=None):
-    def function(data):
-        data = re.sub("[^0-9\.]", "", str(data))
-        if data == "":
+    def function(value):
+        try:
+            amount = decimal.Decimal(str(value))
+            rounded = round(amount, precision)
+            return f"{rounded:.{precision}f}"
+        except (decimal.InvalidOperation, ValueError):
             return "0"
-        return "{:.{prec}f}".format(decimal.Decimal(data), prec=precision)
 
-    if data == None:
-        return function
-    return function(data)
+    return function if data is None else function(data)
 
 
-def ein(data):
-    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 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:])
+    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)
+        data = data.strip()
+        if data.startswith("[") and data.endswith("]"):
+            try:
+                return ast.literal_eval(data)
+            except (SyntaxError, ValueError):
+                return None
+        else:
+            return [data]
     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, char):
-    def inner(data):
-        if data is None:
-            return ""
-        return str(data).rjust(length, char)
+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 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:
+        parsed_data = ast.literal_eval(data)
+        return pformat(parsed_data)
+    except (SyntaxError, ValueError):
         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)