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

velocity/__init__.py

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

velocity/aws/__init__.py

@@ -1,22 +1,18 @@
 import os
 import requests
 
-DEBUG = (os.environ.get('ENV') != 'production') \
-     or (os.environ.get('DEBUG') == 'Y')
+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'
+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')
+        response = requests.get("http://169.254.169.254/latest/meta-data/instance-id")
         instance_id = response.text
         return instance_id
-
-

velocity/aws/handlers/response.py

@@ -1,17 +1,20 @@
-from velocity.misc.format import to_json
 import sys
 import traceback
+from typing import Any, Dict, List, Optional, Union
+from velocity.misc.format import to_json
 from support.app import DEBUG
 
 
-variants = ["success", "error", "warning", "info"]
+class Response:
+    """Class to manage and structure HTTP responses with various actions and custom headers."""
 
+    VALID_VARIANTS = {"success", "error", "warning", "info"}
 
-class Response:
     def __init__(self):
-        self.actions = []
-        self.body = {"actions": self.actions}
-        self.raw = {
+        """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": {
@@ -22,118 +25,266 @@ class Response:
             },
         }
 
-    def render(self):
+    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, title="Notification"):
+    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,
-                },
+                "payload": {"title": title, "message": message},
             }
         )
         return self
 
-    def toast(self, message, variant="success"):
+    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 variants:
-            raise Exception(f"Notistack variant {variant} not in {variants}")
+        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,
-                },
+                "payload": {"options": {"variant": variant}, "message": message},
             }
         )
         return self
 
-    def load_object(self, payload):
+    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):
+    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):
+    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=None):
-        if code:
+    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=None):
+    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:
-            new = {}
-            for key in headers.keys():
-                new["-".join(w.capitalize() for w in key.split("-"))] = headers[key]
-            self.raw["headers"].update(new)
+            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):
+    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):
+    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):
+    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):
-        t, v, tb = sys.exc_info()
+    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(t),
-                    "value": str(v),
+                    "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, title="Notification"):
+    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,
-                },
+                "payload": {"title": title, "message": message},
             }
         )
         return self
 
-    def redirect(self, location):
+    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, location):
-        self.actions.append(
-            {
-                "action": "signout",
-            }
-        )
+    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):
+    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):
+    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/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/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):