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

{velocity-python-0.0.30 → velocity_python-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: velocity-python
-Version: 0.0.30
+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.30 → velocity_python-0.0.32}/pyproject.toml

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

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

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

velocity_python-0.0.32/src/velocity/aws/__init__.py

@@ -0,0 +1,18 @@
+import os
+import requests
+
+DEBUG = (os.environ.get("ENV") != "production") or (os.environ.get("DEBUG") == "Y")
+
+
+# This is helpful for running HTTPS clients on lambda.
+if os.path.exists("/opt/python/ca-certificates.crt"):
+    os.environ["REQUESTS_CA_BUNDLE"] = "/opt/python/ca-certificates.crt"
+
+
+class AWS(object):
+    # Get AWS EC2 Instance ID. Must run this from the EC2 instance itself to get the ID
+    @staticmethod
+    def instance_id(cls):
+        response = requests.get("http://169.254.169.254/latest/meta-data/instance-id")
+        instance_id = response.text
+        return instance_id

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.30 → velocity_python-0.0.32}/src/velocity/db/core/column.py

@@ -1,10 +1,12 @@
 from velocity.db import exceptions
 from velocity.db.core.decorators import return_default
 
+
 class Column(object):
     """
     Represents a column in a database table.
     """
+
     def __init__(self, table, name):
         """
         Initializes a column object with the specified table and name.
@@ -12,11 +14,11 @@ class Column(object):
         Args:
             table (table): The table object that the column belongs to.
             name (str): The name of the column.
-        
+
         Raises:
             Exception: If the table parameter is not of type 'table'.
         """
-        if isinstance(table,str):
+        if isinstance(table, str):
             raise Exception("column table parameter must be a `table` class.")
         self.tx = table.tx
         self.sql = table.tx.engine.sql
@@ -39,13 +41,13 @@ class Column(object):
     NULL OK: %s
     Foreign Key: %s
         """ % (
-        self.table.name,
-        self.name,
-        self.exists(),
-        self.py_type,
-        self.sql_type,
-        self.is_nullok,
-        self.foreign_key_to
+            self.table.name,
+            self.name,
+            self.exists(),
+            self.py_type,
+            self.sql_type,
+            self.is_nullok,
+            self.foreign_key_to,
         )
 
     @property
@@ -55,7 +57,7 @@ class Column(object):
 
         Returns:
             dict: A dictionary containing information about the column.
-        
+
         Raises:
             DbColumnMissingError: If the column does not exist in the database.
         """
@@ -72,7 +74,7 @@ class Column(object):
 
         Returns:
             dict: A dictionary containing information about the foreign key constraint.
-        
+
         Raises:
             DbColumnMissingError: If the column does not exist in the database.
         """
@@ -89,12 +91,14 @@ class Column(object):
 
         Returns:
             str: The name of the referenced table and column in the format 'referenced_table_name.referenced_column_name'.
-        
+
         Raises:
             DbColumnMissingError: If the column does not exist in the database.
         """
         try:
-            return "{referenced_table_name}.{referenced_column_name}".format(**self.foreign_key_info)
+            return "{referenced_table_name}.{referenced_column_name}".format(
+                **self.foreign_key_info
+            )
         except exceptions.DbColumnMissingError:
             return None
 
@@ -105,12 +109,12 @@ class Column(object):
 
         Returns:
             str: The name of the referenced table.
-        
+
         Raises:
             DbColumnMissingError: If the column does not exist in the database.
         """
         try:
-            return self.foreign_key_info['referenced_table_name']
+            return self.foreign_key_info["referenced_table_name"]
         except exceptions.DbColumnMissingError:
             return None
 
@@ -167,7 +171,7 @@ class Column(object):
         self.name = name
 
     @return_default([])
-    def distinct(self, order='asc', qty=None):
+    def distinct(self, order="asc", qty=None):
         """
         Retrieves distinct values from the column.
 
@@ -178,7 +182,12 @@ class Column(object):
         Returns:
             list: A list of distinct values from the column.
         """
-        sql, vals = self.sql.select(columns="distinct {}".format(self.name), table=self.table.name, orderby="{} {}".format(self.name,order), qty=qty)
+        sql, vals = self.sql.select(
+            columns="distinct {}".format(self.name),
+            table=self.table.name,
+            orderby="{} {}".format(self.name, order),
+            qty=qty,
+        )
         return self.tx.execute(sql, vals).as_simple_list().all()
 
     def max(self, where=None):
@@ -190,13 +199,15 @@ class Column(object):
 
         Returns:
             int: The maximum value from the column.
-        
+
         Raises:
             DbTableMissingError: If the table does not exist in the database.
             DbColumnMissingError: If the column does not exist in the database.
         """
         try:
-            sql, vals = self.sql.select(columns="max({})".format(self.name), table=self.table.name, where=where)
+            sql, vals = self.sql.select(
+                columns="max({})".format(self.name), table=self.table.name, where=where
+            )
             return self.tx.execute(sql, vals).scalar()
-        except (exceptions.DbTableMissingError,exceptions.DbColumnMissingError):
+        except (exceptions.DbTableMissingError, exceptions.DbColumnMissingError):
             return 0

{velocity-python-0.0.30 → velocity_python-0.0.32}/src/velocity/db/core/database.py

@@ -1,8 +1,8 @@
 class Database(object):
-    
+
     def __init__(self, tx, name=None):
         self.tx = tx
-        self.name = name or self.tx.engine.config['database']
+        self.name = name or self.tx.engine.config["database"]
         self.sql = tx.engine.sql
 
     def __str__(self):
@@ -12,10 +12,10 @@ class Database(object):
     (db exists) %s
     Tables: %s
         """ % (
-        self.tx.engine.sql.server,
-        self.name,
-        self.exists(),
-        len(self.tables)
+            self.tx.engine.sql.server,
+            self.name,
+            self.exists(),
+            len(self.tables),
         )
 
     def __enter__(self):
@@ -28,7 +28,7 @@ class Database(object):
     def close(self):
         try:
             self._cursor.close()
-            #print("*** database('{}').cursor.close()".format(self.name))
+            # print("*** database('{}').cursor.close()".format(self.name))
         except AttributeError:
             pass
 
@@ -37,7 +37,7 @@ class Database(object):
         try:
             return self._cursor
         except AttributeError:
-            #print("*** database('{}').cursor.open()".format(self.name))
+            # print("*** database('{}').cursor.open()".format(self.name))
             self._cursor = self.tx.cursor()
         return self._cursor
 
@@ -57,7 +57,7 @@ class Database(object):
     @property
     def tables(self):
         sql, vals = self.sql.tables()
-        result = self.tx.execute(sql ,vals, cursor=self.cursor)
+        result = self.tx.execute(sql, vals, cursor=self.cursor)
         return ["%s.%s" % x for x in result.as_tuple()]
 
     def reindex(self):