velocity-python 0.0.31__tar.gz → 0.0.32__tar.gz

{velocity_python-0.0.31 → velocity_python-0.0.32}/PKG-INFO

@@ -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 → velocity_python-0.0.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "velocity-python"
-version = "0.0.31"
+version = "0.0.32"
 authors = [
   { name="Paul Perez", email="pperez@codeclubs.org" },
 ]

{velocity_python-0.0.31 → velocity_python-0.0.32}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.31"
+__version__ = version = "0.0.32"
 
 from . import aws
 from . import db

velocity_python-0.0.32/src/velocity/aws/handlers/response.py

@@ -0,0 +1,290 @@
+import sys
+import traceback
+from typing import Any, Dict, List, Optional, Union
+from velocity.misc.format import to_json
+from support.app import DEBUG
+
+
+class Response:
+    """Class to manage and structure HTTP responses with various actions and custom headers."""
+
+    VALID_VARIANTS = {"success", "error", "warning", "info"}
+
+    def __init__(self):
+        """Initialize the Response object with default status, headers, and an empty actions list."""
+        self.actions: List[Dict[str, Any]] = []
+        self.body: Dict[str, Any] = {"actions": self.actions}
+        self.raw: Dict[str, Any] = {
+            "statusCode": 200,
+            "body": "{}",
+            "headers": {
+                "Content-Type": "application/json",
+                "Access-Control-Allow-Headers": "*",
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "OPTIONS,POST,GET",
+            },
+        }
+
+    def render(self) -> Dict[str, Any]:
+        """
+        Finalize the response body as JSON and return the complete response dictionary.
+
+        Returns:
+            Dict[str, Any]: The complete HTTP response with headers, status code, and JSON body.
+        """
+        self.raw["body"] = to_json(self.body)
+        return self.raw
+
+    def alert(self, message: str, title: str = "Notification") -> "Response":
+        """
+        Add an alert action to the response.
+
+        Args:
+            message (str): The alert message.
+            title (str): Title for the alert. Defaults to "Notification".
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append(
+            {
+                "action": "alert",
+                "payload": {"title": title, "message": message},
+            }
+        )
+        return self
+
+    def toast(self, message: str, variant: str = "success") -> "Response":
+        """
+        Add a toast notification action to the response with a specified variant.
+
+        Args:
+            message (str): The message to display in the toast.
+            variant (str): The style variant of the toast (e.g., "success", "error"). Must be one of VALID_VARIANTS.
+
+        Raises:
+            ValueError: If the variant is not one of VALID_VARIANTS.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        variant = variant.lower()
+        if variant not in self.VALID_VARIANTS:
+            raise ValueError(
+                f"Notistack variant '{variant}' not in {self.VALID_VARIANTS}"
+            )
+        self.actions.append(
+            {
+                "action": "toast",
+                "payload": {"options": {"variant": variant}, "message": message},
+            }
+        )
+        return self
+
+    def load_object(self, payload: Dict[str, Any]) -> "Response":
+        """
+        Add a load-object action to the response with a specified payload.
+
+        Args:
+            payload (Dict[str, Any]): The data to load into the response.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append({"action": "load-object", "payload": payload})
+        return self
+
+    def update_store(self, payload: Dict[str, Any]) -> "Response":
+        """
+        Add an update-store action to the response with a specified payload.
+
+        Args:
+            payload (Dict[str, Any]): The data to update the store with.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append({"action": "update-store", "payload": payload})
+        return self
+
+    def file_download(self, payload: Dict[str, Any]) -> "Response":
+        """
+        Add a file-download action to the response with a specified payload.
+
+        Args:
+            payload (Dict[str, Any]): The data for file download details.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append({"action": "file-download", "payload": payload})
+        return self
+
+    def status(self, code: Optional[int] = None) -> int:
+        """
+        Get or set the status code of the response.
+
+        Args:
+            code (Optional[int]): The HTTP status code to set. If None, returns the current status code.
+
+        Returns:
+            int: The current status code.
+        """
+        if code is not None:
+            self.raw["statusCode"] = int(code)
+        return self.raw["statusCode"]
+
+    def headers(self, headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        """
+        Get or update the headers of the response.
+
+        Args:
+            headers (Optional[Dict[str, str]]): A dictionary of headers to add or update.
+
+        Returns:
+            Dict[str, str]: The current headers after updates.
+        """
+        if headers:
+            formatted_headers = {
+                self._format_header_key(k): v for k, v in headers.items()
+            }
+            self.raw["headers"].update(formatted_headers)
+        return self.raw["headers"]
+
+    def set_status(self, code: int) -> "Response":
+        """
+        Set the HTTP status code of the response.
+
+        Args:
+            code (int): The status code to set.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.status(code)
+        return self
+
+    def set_headers(self, headers: Dict[str, str]) -> "Response":
+        """
+        Set custom headers for the response.
+
+        Args:
+            headers (Dict[str, str]): The headers to add or update.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.headers(headers)
+        return self
+
+    def set_body(self, body: Dict[str, Any]) -> "Response":
+        """
+        Update the body of the response with new data.
+
+        Args:
+            body (Dict[str, Any]): The body data to update.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.body.update(body)
+        return self
+
+    def exception(self) -> None:
+        """
+        Capture and format the current exception details and set a 500 status code.
+        Includes traceback information if DEBUG mode is enabled.
+        """
+        exc_type, exc_value, tb = sys.exc_info()
+        self.set_status(500)
+        self.set_body(
+            {
+                "python_exception": {
+                    "type": str(exc_type),
+                    "value": str(exc_value),
+                    "traceback": traceback.format_exc() if DEBUG else None,
+                    "tb": traceback.format_tb(tb) if DEBUG else None,
+                }
+            }
+        )
+
+    def console(self, message: str, title: str = "Notification") -> "Response":
+        """
+        Add a console log action to the response.
+
+        Args:
+            message (str): The console message.
+            title (str): Title for the console message. Defaults to "Notification".
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append(
+            {
+                "action": "console",
+                "payload": {"title": title, "message": message},
+            }
+        )
+        return self
+
+    def redirect(self, location: str) -> "Response":
+        """
+        Add a redirect action to the response with the target location.
+
+        Args:
+            location (str): The URL to redirect to.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append({"action": "redirect", "payload": {"location": location}})
+        return self
+
+    def signout(self) -> "Response":
+        """
+        Add a signout action to the response.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append({"action": "signout"})
+        return self
+
+    def set_table(self, payload: Dict[str, Any]) -> "Response":
+        """
+        Add a set-table action to the response with the specified payload.
+
+        Args:
+            payload (Dict[str, Any]): The table data to set.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append({"action": "set-table", "payload": payload})
+        return self
+
+    def set_repo(self, payload: Dict[str, Any]) -> "Response":
+        """
+        Add a set-repo action to the response with the specified payload.
+
+        Args:
+            payload (Dict[str, Any]): The repository data to set.
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self.actions.append({"action": "set-repo", "payload": payload})
+        return self
+
+    @staticmethod
+    def _format_header_key(key: str) -> str:
+        """
+        Format HTTP headers to be in a title-cased format.
+
+        Args:
+            key (str): The header key to format.
+
+        Returns:
+            str: The formatted header key.
+        """
+        return "-".join(word.capitalize() for word in key.split("-"))

velocity_python-0.0.32/src/velocity/misc/conv/iconv.py

@@ -0,0 +1,185 @@
+# iconv.py
+import re
+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
+
+
+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: str) -> Optional[str]:
+    """Extracts a 10-digit phone number or returns None if invalid."""
+    if data in ("None", None):
+        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
+
+
+def day_of_week(data: str) -> Optional[int]:
+    """Converts day of the week to an integer representation."""
+    if not data:
+        return None
+    days = {
+        "monday": 1,
+        "tuesday": 2,
+        "wednesday": 3,
+        "thursday": 4,
+        "friday": 5,
+        "saturday": 6,
+        "sunday": 7,
+        "mon": 1,
+        "tue": 2,
+        "wed": 3,
+        "thu": 4,
+        "fri": 5,
+        "sat": 6,
+        "sun": 7,
+    }
+    return days.get(data.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."""
+    try:
+        return datetime.strptime(data, fmt).date()
+    except (ValueError, TypeError):
+        return None
+
+
+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 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 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 integer(data: str) -> int:
+    """Converts a string to an integer, removing non-numeric characters."""
+    return int(re.sub(r"[^0-9\.-]", "", data))
+
+
+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: str) -> str:
+    """Encodes a string using ROT13."""
+    return codecs.encode(data, "rot13")
+
+
+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: str) -> Optional[Decimal]:
+    """Converts a monetary string to a Decimal, removing non-numeric characters."""
+    if data in ("None", None):
+        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."""
+
+    def function(value):
+        if value in ("None", 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
+        )
+
+    return function(data) if data is not None else function
+
+
+def decimal(data: str) -> Optional[Decimal]:
+    """Converts a numeric string to a Decimal, removing non-numeric characters."""
+    if data in ("None", None):
+        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
+
+
+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) 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 lower(data: str) -> str:
+    """Converts a string to lowercase."""
+    return "" if data in (None, "None") else str(data).lower()
+
+
+def upper(data: 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], Optional[str]]:
+    """Pads a string to the specified length with a given character."""
+
+    def inner(data: str) -> Optional[str]:
+        if data in [None, "None", ""]:
+            return None
+        return str(data).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)

velocity_python-0.0.32/src/velocity/misc/conv/oconv.py

@@ -0,0 +1,170 @@
+import re
+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
+
+    if isinstance(data, list):
+        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 (ValueError, TypeError):
+        return ""
+
+
+def rot13(data: str) -> str:
+    """Encodes a string using ROT13."""
+    return codecs.decode(data, "rot13")
+
+
+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: 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_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"
+        )
+
+    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 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) 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: 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 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 inner(data: str) -> str:
+        return str(data).rjust(length, char) if data not in (None, "None", "") else ""
+
+    return inner
+
+
+def pprint(data: str) -> str:
+    """Pretty-prints a JSON-like string representation of data."""
+    try:
+        return pformat(eval(data))
+    except (SyntaxError, NameError):
+        return 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)