velocity-python 0.0.34__py3-none-any.whl → 0.0.64__py3-none-any.whl

velocity/misc/conv/iconv.py

@@ -1,189 +1,375 @@
-# iconv.py
 import re
+import ast
 import codecs
 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
+# Convert JS data to SQL format for storage
 
 
 def none(data: str) -> Optional[str]:
-    """Converts various 'null' representations to None."""
-    return None if data in ("", "null", "None", "@NULL") else data
+    """
+    Converts various 'null' representations to None.
+
+    - Now handles 'null', 'None', '@NULL', or empty string as None.
+    - Returns the original string otherwise.
+    """
+    if data.strip().lower() in ("null", "none", "@null", ""):
+        return None
+    return data
 
 
 def phone(data: str) -> Optional[str]:
-    """Extracts a 10-digit phone number or returns None if invalid."""
-    if data in ("None", None):
+    """
+    Attempts to normalize a phone number.
+
+    - Strips all non-digit characters.
+    - Accepts 10-digit or 11-digit phone numbers.
+      (If 11 digits and starts with '1', we accept the trailing 10 digits).
+    - Returns None if the result is not 10 digits after normalization.
+    """
+    if not data or data.strip().lower() in ("none", "@null"):
         return None
     cleaned_data = re.sub(r"[^0-9]", "", data)
-    match = re.search(r"\d{10}$", cleaned_data)
-    return match.group() if match else None
+    if len(cleaned_data) == 11 and cleaned_data.startswith("1"):
+        cleaned_data = cleaned_data[1:]  # drop leading '1'
+    return cleaned_data if len(cleaned_data) == 10 else None
 
 
 def day_of_week(data: str) -> Optional[int]:
-    """Converts day of the week to an integer representation."""
+    """
+    Converts day of the week to an integer representation (1=Mon,...,7=Sun).
+
+    - Handles both long and short forms: "monday"/"mon", "tuesday"/"tue", etc.
+    - Returns None for unrecognized input.
+    """
     if not data:
         return None
     days = {
         "monday": 1,
-        "tuesday": 2,
-        "wednesday": 3,
-        "thursday": 4,
-        "friday": 5,
-        "saturday": 6,
-        "sunday": 7,
         "mon": 1,
+        "tuesday": 2,
         "tue": 2,
+        "wednesday": 3,
         "wed": 3,
+        "thursday": 4,
         "thu": 4,
+        "friday": 5,
         "fri": 5,
+        "saturday": 6,
         "sat": 6,
+        "sunday": 7,
         "sun": 7,
     }
-    return days.get(data.lower())
+    return days.get(data.strip().lower())
 
 
-def date(data: str, fmt: str = "%Y-%m-%d") -> Optional[datetime.date]:
-    """Parses a date string into a date object using the specified format."""
+def date_conv(data: str, fmt: str = "%Y-%m-%d") -> Optional[datetime.date]:
+    """
+    Parses a date string into a date object using the specified format.
+
+    - Returns None if parsing fails or if 'None' or '@null'.
+    """
+    data_clean = none(data)  # re-use the none() converter
+    if data_clean is None:
+        return None
     try:
-        return datetime.strptime(data, fmt).date()
-    except (ValueError, TypeError):
+        return datetime.strptime(data_clean, fmt).date()
+    except ValueError:
         return None
 
 
-def time(data: str, fmt: str = "%X") -> Optional[datetime.time]:
-    """Parses a time string into a time object using the specified format."""
+def time_conv(data: str, fmt: str = "%H:%M:%S") -> Optional[datetime.time]:
+    """
+    Parses a time string into a time object using the specified format.
+
+    - Defaults to HH:MM:SS if no format is provided.
+    - Returns None if parsing fails or if 'None' or '@null'.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return None
     try:
-        return datetime.strptime(data, fmt).time()
-    except (ValueError, TypeError):
+        return datetime.strptime(data_clean, fmt).time()
+    except ValueError:
         return None
 
 
-def timestamp(data: str, fmt: str = "%c") -> Optional[datetime]:
-    """Parses a timestamp string into a datetime object using the specified format."""
+def timestamp(data: str, fmt: str = "%Y-%m-%d %H:%M:%S") -> Optional[datetime]:
+    """
+    Parses a timestamp string into a datetime object using the specified format.
+
+    - Returns None if parsing fails or if 'None' or '@null'.
+    - Defaults to "%Y-%m-%d %H:%M:%S".
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return None
     try:
-        return datetime.strptime(data, fmt)
-    except (ValueError, TypeError):
+        return datetime.strptime(data_clean, fmt)
+    except ValueError:
         return None
 
 
 def email(data: str) -> Optional[str]:
-    """Validates and returns an email address if properly formatted."""
-    if not data or data.lower() == "none":
+    """
+    Validates and returns a cleaned email address if properly formatted.
+
+    - Uses parseaddr and requires an '@' and at least one '.' after '@'.
+    - Returns None if invalid or if 'None'/'@null'.
+    - This is still quite basic compared to more advanced email validation needs.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return None
+
+    data_clean = data_clean.strip().lower()
+    # parseaddr only reliably splits out the email part
+    addr = parseaddr(data_clean)[1]
+    if "@" not in addr:
+        return None
+    # At least one '.' after the '@'
+    domain_part = addr.split("@", 1)[-1]
+    if "." not in domain_part:
         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")
+    return addr
 
 
-def integer(data: str) -> int:
-    """Converts a string to an integer, removing non-numeric characters."""
-    cleaned_data = re.sub(r"[^0-9\.-]", "", data)
+def integer(data: str) -> Optional[int]:
+    """
+    Converts a string to an integer, removing non-numeric (and '.') characters.
+
+    - Returns None if conversion fails or if 'None'/'@null'.
+    - Accepts optional leading sign and decimal point, but truncates toward int.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return None
+
+    # Keep digits, sign, and decimal
+    cleaned = re.sub(r"[^0-9\.\-+]", "", data_clean)
+    if cleaned.count(".") > 1:
+        # Too many decimal points => treat as invalid
+        return None
     try:
-        return int(float(cleaned_data))
+        return int(float(cleaned))
     except ValueError:
-        raise ValueError(f"Cannot convert {data} to integer.")
+        return None
 
 
 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"]:
+    """
+    Converts various string representations to a boolean.
+
+    - 'false', '', 'f', 'off', '0', and 'no' => False
+    - Everything else => True
+    - If data is already bool, it is returned as is.
+    """
+    if isinstance(data, bool):
+        return data
+    data_str = str(data).strip().lower()
+    if data_str in ["false", "", "f", "off", "0", "no", "@null", "none"]:
         return False
-    return bool(data)
+    return True
+
+
+def rot13(data: str) -> Optional[str]:
+    """
+    Encodes a string using ROT13.
 
+    - Returns None if input is None or 'None' or '@null'.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return None
+    return codecs.encode(data_clean, "rot13")
 
-def rot13(data: str) -> str:
-    """Encodes a string using ROT13."""
-    return codecs.encode(data, "rot13")
 
+def pointer(data: str) -> Optional[int]:
+    """
+    Converts a pointer-like string to an integer, or returns None for special tokens.
 
-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):
+    - If data is '@new', '@null', 'None', or empty => returns None.
+    - Otherwise tries to parse as int; returns None if it fails.
+    """
+    data_clean = none(data)
+    if data_clean is None or data_clean.lower() == "@new":
+        return None
+
+    # Attempt to parse as integer
+    cleaned = re.sub(r"[^0-9\+\-]", "", data_clean)
+    if not cleaned:
+        return None
+    try:
+        return int(cleaned)
+    except ValueError:
         return None
-    return int(data)
 
 
 def money(data: str) -> Optional[Decimal]:
-    """Converts a monetary string to a Decimal, removing non-numeric characters."""
-    if data in ("None", None):
+    """
+    Converts a monetary string to a Decimal, removing non-numeric characters.
+
+    - Returns None if 'None' or '@null' or if parse fails.
+    - Example input: "$12,345.67" => Decimal("12345.67")
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return None
+
+    cleaned = re.sub(r"[^0-9\.\-]", "", data_clean)
+    if cleaned.count(".") > 1:
+        return None
+    try:
+        return Decimal(cleaned)
+    except:
         return None
-    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."""
+) -> Union[Decimal, Callable[[Union[str, float, Decimal]], Optional[Decimal]]]:
+    """
+    Rounds a number to a specified precision.
+
+    - If called with data, returns a single rounded Decimal or None.
+    - If called without data, returns a function that can be used as a converter.
+    """
 
-    def function(value):
-        if value in ("None", None):
+    def _round_inner(val: Union[str, float, Decimal, None]) -> Optional[Decimal]:
+        val_str = none(str(val)) if val is not None else None
+        if val_str is None:
             return None
-        if isinstance(value, str):
-            value = re.sub(r"[^0-9\.-]", "", value)
-        return Decimal(value).quantize(
-            Decimal(10) ** -precision, rounding=ROUND_HALF_UP
-        )
+        # Remove non-numeric (except decimal, sign)
+        cleaned = re.sub(r"[^0-9\.\-+]", "", val_str)
+        try:
+            as_dec = Decimal(cleaned)
+        except:
+            return None
+        return as_dec.quantize(Decimal(10) ** -precision, rounding=ROUND_HALF_UP)
+
+    return _round_inner(data) if data is not None else _round_inner
 
-    return function(data) if data is not None else function
 
+def decimal_val(data: str) -> Optional[Decimal]:
+    """
+    Converts a numeric string to a Decimal, removing non-numeric characters.
 
-def decimal(data: str) -> Optional[Decimal]:
-    """Converts a numeric string to a Decimal, removing non-numeric characters."""
-    if data in ("None", None):
+    - Returns None if 'None'/'@null' or parse fails.
+    - Accepts a single decimal point; returns None if multiple decimals.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return None
+    cleaned = re.sub(r"[^0-9\.\-]", "", data_clean)
+    # if multiple decimal points => invalid
+    if cleaned.count(".") > 1:
+        return None
+    try:
+        return Decimal(cleaned)
+    except:
         return None
-    return Decimal(re.sub(r"[^0-9\.-]", "", data))
 
 
 def ein(data: str) -> Optional[str]:
-    """Validates and returns a 9-digit EIN, or None if invalid."""
-    if data in ("None", None):
-        return None
-    cleaned_data = re.sub(r"[^0-9]", "", data)
-    match = re.fullmatch(r"\d{9}", cleaned_data)
-    return match.group() if match else None
+    """
+    Validates and returns a 9-digit EIN, or None if invalid.
 
-
-def to_list(data: Union[str, list]) -> Optional[list]:
-    """Converts a string or single element into a list representation."""
-    if data in (None, "None"):
+    - Strips non-digit chars; must be exactly 9 digits.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return None
+    cleaned_data = re.sub(r"[^0-9]", "", data_clean)
+    if len(cleaned_data) == 9:
+        return cleaned_data
+    return None
+
+
+def to_list(data: Union[str, list, None]) -> Optional[list]:
+    """
+    Converts a string or single element into a list representation.
+
+    - Returns None for 'None'/'@null' or empty string.
+    - If data is already a list, returns it.
+    - If data looks like a Python list string, attempts to eval it safely.
+    - Otherwise returns a 1-element list with that data.
+    """
+    if not data or str(data).lower().strip() in ("none", "@null", ""):
         return None
-    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
+    if isinstance(data, list):
+        return data
+    data_str = str(data).strip()
+    if data_str.startswith("[") and data_str.endswith("]"):
+        try:
+            return ast.literal_eval(data_str)
+        except:
+            return [data_str]  # fallback: treat as a single string
+    return [data_str]
 
 
 def title(data: str) -> str:
-    """Converts a string to title case."""
-    return "" if data in (None, "None") else str(data).title()
+    """
+    Converts a string to title case.
+
+    - Returns empty string if 'None'/'@null' or empty input.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return ""
+    return data_clean.title()
 
 
 def lower(data: str) -> str:
-    """Converts a string to lowercase."""
-    return "" if data in (None, "None") else str(data).lower()
+    """
+    Converts a string to lowercase.
+
+    - Returns empty string if 'None'/'@null' or empty input.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return ""
+    return data_clean.lower()
 
 
 def upper(data: str) -> str:
-    """Converts a string to uppercase."""
-    return "" if data in (None, "None") else str(data).upper()
+    """
+    Converts a string to uppercase.
+
+    - Returns empty string if 'None'/'@null' or empty input.
+    """
+    data_clean = none(data)
+    if data_clean is None:
+        return ""
+    return data_clean.upper()
 
 
 def padding(length: int, char: str = " ") -> Callable[[str], Optional[str]]:
-    """Pads a string to the specified length with a given character."""
+    """
+    Pads a string to the specified length with a given character on the left.
+
+    - If data is None/'None'/'@null' or empty, returns None.
+    """
 
     def inner(data: str) -> Optional[str]:
-        if data in [None, "None", ""]:
+        data_clean = none(data)
+        if data_clean is None:
             return None
-        return str(data).rjust(length, char)
+        return data_clean.rjust(length, char)
 
     return inner
 
 
 def string(data: str) -> Optional[str]:
-    """Converts an empty string to None, otherwise returns the string itself."""
-    return None if data == "" else str(data)
+    """
+    Converts an empty string to None, otherwise returns the string.
+
+    - Also treats 'None', '@null' as None.
+    """
+    data_clean = none(data)
+    # If none() returned None, it’s None. Else, check if empty.
+    if data_clean is None:
+        return None
+    return data_clean if data_clean else None

velocity/misc/conv/oconv.py

@@ -1,4 +1,3 @@
-# oconv.py
 import re
 import codecs
 import decimal
@@ -12,7 +11,7 @@ import ast
 
 def none(data: Optional[str]) -> str:
     """Converts various 'null' representations to an empty string."""
-    return "" if data in (None, "None", "null", "@NULL") else data
+    return "" if data in (None, "None", "null", "@NULL", "@null") else data
 
 
 def phone(data: Optional[str]) -> str:
@@ -58,7 +57,7 @@ def day_of_week(data: Union[int, str, List], abbrev: bool = False) -> str:
         return ""
 
 
-def date(
+def date_conv(
     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."""
@@ -69,7 +68,9 @@ def date(
     )
 
 
-def time(data: Union[datetime.datetime, datetime.time, str], fmt: str = "%X") -> str:
+def time_conv(
+    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)

velocity/misc/db.py

@@ -36,9 +36,9 @@ class join(object):
         vals.extend(args)
         for key, val in kwargs.items():
             if isinstance(val, numbers.Number):
-                vals.append("{}={}".format(key, val))
+                vals.append(f"{key}={val}")
             else:
-                vals.append("{}='{}'".format(key, val))
+                vals.append(f"{key}='{val}'")
         return vals
 
 

velocity/misc/format.py

@@ -66,10 +66,10 @@ def to_json(o, datefmt: str = "%Y-%m-%d", timefmt: str = "%H:%M:%S") -> str:
                 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, date):
+                return obj.strftime(datefmt)
             elif isinstance(obj, time):
                 return obj.strftime(timefmt)
             elif isinstance(obj, timedelta):

{velocity_python-0.0.34.dist-info → velocity_python-0.0.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: velocity-python
-Version: 0.0.34
+Version: 0.0.64
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Paul Perez <pperez@codeclubs.org>
 Project-URL: Homepage, https://codeclubs.org/projects/velocity
@@ -15,11 +15,11 @@ Requires-Dist: jinja2
 Requires-Dist: xlrd
 Requires-Dist: openpyxl
 Provides-Extra: mysql
-Requires-Dist: mysql-connector-python ; extra == 'mysql'
-Provides-Extra: postgres
-Requires-Dist: psycopg2-binary ; extra == 'postgres'
+Requires-Dist: mysql-connector-python; extra == "mysql"
 Provides-Extra: sqlserver
-Requires-Dist: python-tds ; extra == 'sqlserver'
+Requires-Dist: python-tds; extra == "sqlserver"
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary; extra == "postgres"
 
 # Velocity.DB
 

velocity_python-0.0.64.dist-info/RECORD

@@ -0,0 +1,47 @@
+velocity/__init__.py,sha256=BV64vuHaj6lbPZ96w6YkJ_mgqq506ohvETaJVjBy-_s,88
+velocity/aws/__init__.py,sha256=GBTEr02whnCH3TG-BWCpUC3KfHY3uNxD21g0OvsVJnc,598
+velocity/aws/handlers/__init__.py,sha256=xnpFZJVlC2uoeeFW4zuPST8wA8ajaQDky5Y6iXZzi3A,172
+velocity/aws/handlers/context.py,sha256=UIjNR83y2NSIyK8HMPX8t5tpJHFNabiZvNgmmdQL3HA,1822
+velocity/aws/handlers/lambda_handler.py,sha256=RfEFIIn6a2k0W25AMEOMWCqbpUkXF13kV6vXFVKz0b0,6309
+velocity/aws/handlers/response.py,sha256=LXhtizLKnVBWjtHyE0h0bk-NYDrRpj7CHa7tRz9KkC4,9324
+velocity/aws/handlers/sqs_handler.py,sha256=YBqrEkA6EfkQUVk_kwsSI-HjFJO8-JqYco-p0UYDNXE,3368
+velocity/db/__init__.py,sha256=vrn2AFNAKaqTdnPwLFS0OcREcCtzUCOodlmH54U7ADg,200
+velocity/db/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+velocity/db/core/column.py,sha256=tAr8tL3a2nyaYpNHhGl508FrY_pGZTzyYgjAV5CEBv4,4092
+velocity/db/core/database.py,sha256=3zNGItklu9tZCKsbx2T2vCcU1so8AL9PPL0DLjvaz6s,3554
+velocity/db/core/decorators.py,sha256=ZwwNc6wGx7Qe7xPZGgeHuqqtXEeNqyDXB0M5ROY-40I,4612
+velocity/db/core/engine.py,sha256=Ykw_G78UeS59JZLRHqOrprfOv-uxm7HshA6V0cST6QE,13074
+velocity/db/core/exceptions.py,sha256=MOWyA1mlMe8eWbFkEHK0Lp9czdplpRyqbAn2JfGmMrM,707
+velocity/db/core/result.py,sha256=OVqoMwlx3CHNNwr-JGWRx5I8u_YX6hlUpecx99UT5nE,6164
+velocity/db/core/row.py,sha256=aliLYTTFirgJsOvmUsANwJMyxaATuhpGpFJhcu_twwY,6709
+velocity/db/core/sequence.py,sha256=VMBc0ZjGnOaWTwKW6xMNTdP8rZ2umQ8ml4fHTTwuGq4,3904
+velocity/db/core/table.py,sha256=1zI_GgkUCCjRmM30OGiLOgJnnAeJNkriK_mYeV34lC0,35058
+velocity/db/core/transaction.py,sha256=SMkgu39IbgjOIeTzhXo_k7XEEc9MDvztphEYp-fUdQ0,6506
+velocity/db/servers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+velocity/db/servers/mysql.py,sha256=qHwlB_Mg02R7QFjD5QvJCorYYiP50CqEiQyZVl3uYns,20914
+velocity/db/servers/mysql_reserved.py,sha256=CYdZJBOpS-ptImaRZcmVLumdUdbFuf9Tfdzu_mUT5wY,3507
+velocity/db/servers/sqlite.py,sha256=X210a5pENT9PiVK7f16fxXzFwEsq8fSe58Vouv2xqlk,33234
+velocity/db/servers/sqlite_reserved.py,sha256=-xmjl-Hgu6lKqkCAXq_6U8_aJX6gvaMgLMLdCt-Ej7o,3006
+velocity/db/servers/sqlserver.py,sha256=0uGLEWRXiUhrOVTpEA1zvaKq1mcfiaCDp9r7gX-N71g,29914
+velocity/db/servers/sqlserver_reserved.py,sha256=3LGQYU0qfvk6AbKety96gbzzfLbZ0dNHDPLxKGvvi4Q,4596
+velocity/db/servers/tablehelper.py,sha256=0QsQc73q2En3p0778DKAEiEo3ZtZowgFpAKZXwORjfw,9816
+velocity/db/servers/postgres/__init__.py,sha256=n6Ti5USqXME8Df18iklC-D0eI1Hr0szZAeSS3xz5ycQ,464
+velocity/db/servers/postgres/operators.py,sha256=A2T1qFwhzPl0fdXVhLZJhh5Qfx-qF8oZsDnxnq2n_V8,389
+velocity/db/servers/postgres/reserved.py,sha256=5tKLaqFV-HrWRj-nsrxl5KGbmeM3ukn_bPZK36XEu8M,3648
+velocity/db/servers/postgres/sql.py,sha256=-hJ6Ly9iZY3SoAJFjrSjLUAAYPMwG-28RyFRh-Owbpo,35453
+velocity/db/servers/postgres/types.py,sha256=Wa45ppVf_pdWul-jYWFRGMl6IdSq8dAp10SKnhL7osQ,3757
+velocity/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+velocity/misc/db.py,sha256=MPgt-kkukKR_Wh_S_5W-MyDgaeoZ4YLoDJ54wU2ppm4,2830
+velocity/misc/export.py,sha256=lATvwTe-Of6X7ZtzvJZiFghh9QlyMYZfDfQ_GJyt5yg,5197
+velocity/misc/format.py,sha256=fA5ai3kp-bLhPCCg7Yq9XPhUCE3In-jVZobjBGvmHDg,2649
+velocity/misc/mail.py,sha256=BrxDqeVsOd0epyJKwrHA-owzs6di2oLA_qJskoTux-c,2553
+velocity/misc/merge.py,sha256=EYtqwnckBllPO60tRALxFRuzmUQ7Wl0qZC6sCgyiZDA,1885
+velocity/misc/timer.py,sha256=cN3aS0t6HLlhYfF2Ir6ihJehxNrWf9ebaLzXUaWRKEA,1637
+velocity/misc/conv/__init__.py,sha256=MLYF58QHjzfDSxb1rdnmLnuEQCa3gnhzzZ30CwZVvQo,40
+velocity/misc/conv/iconv.py,sha256=d4_BucW8HTIkGNurJ7GWrtuptqUf-9t79ObzjJ5N76U,10603
+velocity/misc/conv/oconv.py,sha256=h5Lo05DqOQnxoD3y6Px_MQP_V-pBbWf8Hkgkb9Xp1jk,6032
+velocity_python-0.0.64.dist-info/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.64.dist-info/METADATA,sha256=vAWChPbSU4kqhj3uwJP8mdpgT2SvwyHY84Dv_l8FQ6E,8519
+velocity_python-0.0.64.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+velocity_python-0.0.64.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.64.dist-info/RECORD,,

{velocity_python-0.0.34.dist-info → velocity_python-0.0.64.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any