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

velocity/misc/format.py

@@ -1,47 +1,45 @@
 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)
+    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)
+    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)
+    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)
+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)
 
@@ -57,26 +55,25 @@ def human_delta(tdelta):
     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,74 +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 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):
+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,
+        "body": body.decode("utf-8") if body else None,
+        "html": html.decode("utf-8") if html else None,
         "attachments": attachments,
     }

velocity/misc/merge.py

@@ -1,36 +1,52 @@
 from copy import deepcopy
 from functools import reduce
+from typing import Dict, List, Any
 
 
-def deep_merge(*dicts, update=False):
+def deep_merge(*dicts: Dict[str, Any], update: bool = False) -> Dict[str, Any]:
     """
-    Merges dicts deeply.
+    Deeply merges multiple dictionaries.
+
     Parameters
     ----------
-    dicts : list[dict]
-        List of dicts.
-    update : bool
-        Whether to update the first dict or create a new dict.
+    *dicts : Dict[str, Any]
+        Variable number of dictionaries to merge.
+    update : bool, optional
+        If True, updates the first dictionary in-place.
+        If False, creates and returns a new merged dictionary. Default is False.
+
     Returns
     -------
-    merged : dict
-        Merged dict.
+    Dict[str, Any]
+        The merged dictionary.
+
+    Notes
+    -----
+    - If a key's value in two dictionaries is a dictionary, they are merged recursively.
+    - If a key's value in two dictionaries is a list, values from the second list
+      are added to the first, avoiding duplicates.
+    - For all other types, the value from the latter dictionary overwrites the former.
     """
 
-    def merge_into(d1, d2):
-        for key in d2:
+    def merge_into(d1: Dict[str, Any], d2: Dict[str, Any]) -> Dict[str, Any]:
+        for key, value in d2.items():
             if key not in d1:
-                d1[key] = deepcopy(d2[key])
-            elif isinstance(d1[key], dict):
-                d1[key] = merge_into(d1[key], d2[key])
-            elif isinstance(d1[key], list) and isinstance(d2[key], list):
-                d1[key].extend(d2[key])
+                d1[key] = deepcopy(value)
+            elif isinstance(d1[key], dict) and isinstance(value, dict):
+                d1[key] = merge_into(d1[key], value)
+            elif isinstance(d1[key], list) and isinstance(value, list):
+                existing_items = set(d1[key])
+                d1[key].extend(x for x in value if x not in existing_items)
+                existing_items.update(
+                    value
+                )  # Keep the set updated for further iterations
             else:
-                d1[key] = deepcopy(d2[key])
-
+                d1[key] = deepcopy(value)  # Overwrite with the new value
         return d1
 
     if update:
+        # Update the first dictionary in-place
         return reduce(merge_into, dicts[1:], dicts[0])
     else:
+        # Create a new dictionary for the merged result
         return reduce(merge_into, dicts, {})

velocity/misc/timer.py

@@ -1,27 +1,50 @@
 import time
+from typing import Optional
 
 
 class Timer:
-    def __init__(self, label="Timer"):
+    def __init__(self, label: str = "Timer"):
+        """
+        Initializes a Timer instance with an optional label and starts the timer.
+        """
         self._label = label
+        self._start: Optional[float] = None
+        self._end: Optional[float] = None
+        self._diff: Optional[float] = None
         self.start()
 
-    def start(self):
-        self._end = self._start = time.time()
-        self._diff = 0
+    def start(self) -> None:
+        """Starts or restarts the timer."""
+        self._start = time.time()
+        self._end = None
+        self._diff = None
 
-    def end(self):
+    def stop(self) -> float:
+        """Stops the timer and calculates the time elapsed."""
+        if self._start is None:
+            raise ValueError("Timer has not been started.")
         self._end = time.time()
         self._diff = self._end - self._start
+        return self._diff
 
-    def __str__(self):
-        if not self._diff:
-            self.end()
-        return f"{self._label}: {self._diff:.4f} s"
+    def elapsed(self) -> float:
+        """Returns the elapsed time in seconds without stopping the timer."""
+        if self._start is None:
+            raise ValueError("Timer has not been started.")
+        return time.time() - self._start
+
+    def __str__(self) -> str:
+        """Returns a string representation of the time elapsed or final time."""
+        if self._diff is not None:  # Timer has been stopped
+            return f"{self._label}: {self._diff:.4f} s"
+        else:  # Timer is still running, show elapsed time
+            return f"{self._label}: {self.elapsed():.4f} s"
 
 
 if __name__ == "__main__":
     t = Timer("My Label")
     time.sleep(0.003)
+    print(t)  # Should display elapsed time
     time.sleep(3)
-    print(t)
+    t.stop()
+    print(t)  # Should display the stopped time (final diff)

{velocity_python-0.0.31.dist-info → velocity_python-0.0.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: velocity-python
-Version: 0.0.31
+Version: 0.0.32
 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

{velocity_python-0.0.31.dist-info → velocity_python-0.0.32.dist-info}/RECORD

@@ -1,9 +1,9 @@
-velocity/__init__.py,sha256=OeRnEfJy9NabRsxHYEQSJCo2jOlOxfmggEKOqDzaCXc,88
+velocity/__init__.py,sha256=8Xcz_RUYvy6ibGGQeUrwa-fEVzDMhSKe2ZnYgytCeTw,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=PlbrTFWZ6-2s7MGqaGAYENVuL63wOC7FlW7ZogFyTKo,3869
+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
@@ -24,16 +24,16 @@ velocity/db/servers/sqlite.py,sha256=_PGg6ECHdOyOMn4tTWX4WlectAukW3Dov7cZxHbVtBM
 velocity/db/servers/sqlserver.py,sha256=ACdkTyJzdFzN-RpmOabKgmMPtCdHzT-FwYH00UpSNyM,34465
 velocity/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/misc/db.py,sha256=MtuNa7Z6F4SBy9wCXqLpSzWOJMkx51Z3vpUxn4FgUqU,2850
-velocity/misc/export.py,sha256=LgvlexQal3O2OMvMuvWmY17PzK2xsv1cG44YXnBDSig,4348
-velocity/misc/format.py,sha256=5hUVxBR1r-e0jrQwxiZx5dU5u-TsMnRVuCFNuczTpAs,2302
-velocity/misc/mail.py,sha256=SmX-9v79lxOflgcc-L-ME9HW07sfayIiuCg1zA3EDIw,2129
-velocity/misc/merge.py,sha256=ouzXOab7BX5Codo_goHqvrFMfjlRn8nVnUZj9A8MRMk,902
-velocity/misc/timer.py,sha256=HEV64eQPTNx_3aeUTCP2_st4zPDHEDmclQM9R5r7wDg,537
+velocity/misc/export.py,sha256=lATvwTe-Of6X7ZtzvJZiFghh9QlyMYZfDfQ_GJyt5yg,5197
+velocity/misc/format.py,sha256=OnjkxEEKzKuwihdf570VDSpsqOJLp0iyW0cuyDaxL-U,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=V-PcpDXq7wCmyxZ3sXfzpmVH5Nc9OHScvMH26K7N3bI,4375
-velocity/misc/conv/oconv.py,sha256=p5_lNU7SHIp6vSBzDaAZJ7M2w1Hs7zSn5z6Hndvfb0o,4071
-velocity_python-0.0.31.dist-info/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.31.dist-info/METADATA,sha256=EB7kL6jeO1lXfC97K8WPELfDJIp49N_LqgieOxKg0BA,8522
-velocity_python-0.0.31.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-velocity_python-0.0.31.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.31.dist-info/RECORD,,
+velocity/misc/conv/iconv.py,sha256=ThTT3_t0Us5P7UuBa58ko-GKVm30FFUrSmPBd6Gfh90,5660
+velocity/misc/conv/oconv.py,sha256=XdRTQnywWNwVc0FH-8hPHjlTpZNFg80ivIfyTV3mMak,5495
+velocity_python-0.0.32.dist-info/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.32.dist-info/METADATA,sha256=teq0KrZ_b16Wx7QWDWpXIChNmAxJMiKbyjBMDt_9uf4,8522
+velocity_python-0.0.32.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+velocity_python-0.0.32.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.32.dist-info/RECORD,,