velocity-python 0.0.30__py3-none-any.whl → 0.0.32__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/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,137 @@ 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."""
+    return int(re.sub(r"[^0-9\.-]", "", data))
 
 
-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 +180,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

@@ -3,202 +3,168 @@ 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: Optional[str]) -> str:
+    """Converts various 'null' representations to an empty string."""
+    return "" if data in (None, "None", "null", "@NULL") else data
+
+
+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 ""
+    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: 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",
+        4: "Thursday",
+        5: "Friday",
+        6: "Saturday",
+        7: "Sunday",
+    }
+    days_abbrev = {1: "Mon", 2: "Tue", 3: "Wed", 4: "Thu", 5: "Fri", 6: "Sat", 7: "Sun"}
+    days = days_abbrev if abbrev else days_full
 
-def none(data):
-    if data == None:
-        return ''
-    if data == 'None':
-        return ''
-    if data == 'null':
-        return ''
-    return data
-
-
-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:])
-
-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 {
-        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')
-    def _(param):
-        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')
-    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 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 _
-
-
-def email(data):
-    if data == None:
-        return ''
-    if data == 'None':
-        return ''
-    return data.lower()
-
-
-def pointer(data):
+        return ",".join(day_of_week(day, abbrev) for day in data if day in days)
+
+    try:
+        return days[int(data)]
+    except (ValueError, KeyError, TypeError):
+        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 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 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: 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: 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:
-        return ''
+    except (ValueError, TypeError):
+        return ""
 
 
-def rot13(data):
-    return codecs.decode(data,'rot13')
+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):
-    if data in [None,'']:
-        return ''
-    data = re.sub("[^0-9\.-]", "", str(data))
-    return '${:,.2f}'.format(decimal.Decimal(data))
+def money(data: str) -> str:
+    """Formats a numeric string as currency."""
+    if data in [None, ""]:
+        return ""
+    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)
-    if data == None:
-        return function
-    return function(data)
+def round_to(
+    precision: int, data: Optional[Union[str, float, decimal.Decimal]] = None
+) -> Union[Callable, str]:
+    """Rounds a number to the specified precision."""
 
+    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"
+        )
 
-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:])
+    return function if data is None else function(data)
+
+
+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 ""
+    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):
-    if data in (None,'None'):
+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: Optional[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: Optional[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], 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 ""
 
-def padding(length, char):
-    def inner(data):
-        if data is None:
-            return ''
-        return str(data).rjust(length, char)
     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)