velocity-python 0.0.84__tar.gz → 0.0.86__tar.gz

{velocity_python-0.0.84/src/velocity_python.egg-info → velocity_python-0.0.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.84
+Version: 0.0.86
 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.84 → velocity_python-0.0.86}/pyproject.toml

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

{velocity_python-0.0.84 → velocity_python-0.0.86}/src/velocity/__init__.py

@@ -1,5 +1,6 @@
-__version__ = version = "0.0.84"
+__version__ = version = "0.0.86"
 
 from . import aws
 from . import db
 from . import misc
+from . import app

velocity_python-0.0.86/src/velocity/app/orders.py

@@ -0,0 +1,182 @@
+import datetime
+import support.app
+import pprint
+
+engine = support.app.postgres()
+REQUIRED = object()
+
+
+@engine.transaction
+class Order:
+    SCHEMA = {
+        "headers": {
+            "customer_email": REQUIRED,
+            "order_date": REQUIRED,
+            "order_type": REQUIRED,
+        },
+        "lineitems": {
+            "sku": REQUIRED,
+            "qty": REQUIRED,
+            "price": REQUIRED,
+        },
+        "lineitems_supp": {
+            "note": str,
+        },
+    }
+
+    DEFAULTS = {
+        "headers": {
+            "order_date": lambda: datetime.date.today(),
+            "effective_date": lambda: datetime.date.today(),
+        }
+    }
+
+    def __init__(self, order_id=None):
+        self.order_id = order_id
+        self.headers = {}
+        self.lineitems = {}
+        self.lineitems_supp = {}
+
+    def __repr__(self):
+        return f"Order(order_id={self.order_id}, headers={pprint.pformat(self.headers)}, lineitems={pprint.pformat(self.lineitems)}, lineitems_supp={pprint.pformat(self.lineitems_supp)})"
+
+    def exists(self, tx):
+        if not self.order_id:
+            raise ValueError("order_id must be set to check existence")
+        return tx.table("orders").find(self.order_id)
+
+    def __bool__(self):
+        return bool(self.order_id) and self.exists(engine.transaction())
+
+    def load(self, tx):
+        if not self.order_id:
+            raise ValueError("order_id must be set to load an order")
+
+        order = tx.table("orders").one(self.order_id)
+        if not order:
+            raise ValueError(f"Order {self.order_id} not found")
+
+        self.headers = dict(order)
+
+        items = (
+            tx.table("order_lineitems")
+            .select(where={"order_id": self.order_id}, orderby="line_number")
+            .all()
+        )
+        for idx, row in enumerate(items):
+            self.lineitems[idx] = dict(row)
+
+        supps = (
+            tx.table("order_lineitems_supp")
+            .select(where={"order_id": self.order_id}, orderby="line_number")
+            .all()
+        )
+        for idx, row in enumerate(supps):
+            self.lineitems_supp[idx] = dict(row)
+
+    def update_header(self, key, value):
+        self.headers[key] = value
+
+    def add_lineitem(self, data: dict, supp_data: dict = None):
+        index = len(self.lineitems)
+        self.lineitems[index] = data
+        self.lineitems_supp[index] = supp_data or {}
+
+    def update_lineitem(self, index: int, data: dict = None, supp_data: dict = None):
+        if index not in self.lineitems:
+            raise IndexError(f"No line item at index {index}")
+        if data:
+            self.lineitems[index].update(data)
+        if supp_data is not None:
+            self.lineitems_supp[index].update(supp_data)
+
+    def delete_lineitem(self, index: int):
+        if index not in self.lineitems:
+            raise IndexError(f"No line item at index {index}")
+        del self.lineitems[index]
+        if index in self.lineitems_supp:
+            del self.lineitems_supp[index]
+        self._reindex_lineitems()
+
+    def _reindex_lineitems(self):
+        """Re-index lineitems and supplemental data after deletion."""
+        new_items = {}
+        new_supps = {}
+        for i, key in enumerate(sorted(self.lineitems)):
+            new_items[i] = self.lineitems[key]
+            new_supps[i] = self.lineitems_supp.get(key, {})
+        self.lineitems = new_items
+        self.lineitems_supp = new_supps
+
+    def _apply_defaults(self):
+        for section, defaults in self.DEFAULTS.items():
+            target = getattr(self, section)
+            for key, default in defaults.items():
+                if key not in target:
+                    target[key] = default() if callable(default) else default
+                elif key == "updated_at":
+                    # Always update updated_at if present
+                    target[key] = default() if callable(default) else default
+
+    def _validate(self):
+        self._apply_defaults()
+
+        for key, requirement in self.SCHEMA["headers"].items():
+            if requirement is REQUIRED and key not in self.headers:
+                raise ValueError(f"Missing required header field: {key}")
+            if (
+                key in self.headers
+                and requirement is not REQUIRED
+                and not isinstance(self.headers[key], requirement)
+            ):
+                raise TypeError(
+                    f"Header field '{key}' must be of type {requirement.__name__}"
+                )
+
+        for idx, item in self.lineitems.items():
+            for key, requirement in self.SCHEMA["lineitems"].items():
+                if requirement is REQUIRED and key not in item:
+                    raise ValueError(f"Line item {idx} missing required field: {key}")
+
+        for idx, supp in self.lineitems_supp.items():
+            for key, expected in self.SCHEMA["lineitems_supp"].items():
+                if key in supp and not isinstance(supp[key], expected):
+                    raise TypeError(
+                        f"Supplemental field '{key}' in item {idx} must be of type {expected.__name__}"
+                    )
+
+    def persist(self, tx):
+        self._validate()
+
+        if self.order_id:
+            tx.table("orders").update(self.headers, self.order_id)
+        else:
+            record = tx.table("orders").new(self.headers)
+            self.order_id = record["sys_id"]
+
+        tx.table("order_lineitems").delete(where={"order_id": self.order_id})
+        tx.table("order_lineitems_supp").delete(where={"order_id": self.order_id})
+
+        for index in sorted(self.lineitems):
+            tx.table("order_lineitems").insert(
+                {
+                    "order_id": self.order_id,
+                    "line_number": index,
+                    **self.lineitems[index],
+                }
+            )
+            tx.table("order_lineitems_supp").insert(
+                {
+                    "order_id": self.order_id,
+                    "line_number": index,
+                    **self.lineitems_supp.get(index, {}),
+                }
+            )
+
+    def to_dict(self):
+        return {
+            "order_id": self.order_id,
+            "headers": self.headers,
+            "lineitems": self.lineitems,
+            "lineitems_supp": self.lineitems_supp,
+        }

{velocity_python-0.0.84 → velocity_python-0.0.86}/src/velocity/aws/handlers/lambda_handler.py

@@ -158,10 +158,6 @@ class LambdaHandler:
         tx.table(helpers.get_tracking_table(user or self.session)).insert(data)
 
     def OnActionDefault(self, tx, context):
-        print("[ERROR] AWS_EVENT", str(self.aws_event))
-        print("[ERROR] AWS_EVENT", dir(self.aws_event))
-        print("[ERROR] AWS_EVENT", self.aws_event)
-
         context.response().set_body(
             {"event": self.aws_event, "postdata": context.postdata()}
         )

{velocity_python-0.0.84 → velocity_python-0.0.86}/src/velocity/db/core/decorators.py

@@ -88,7 +88,6 @@ def return_default(
                 if result is None:
                     result = default
             except func.exceptions:
-                traceback.print_exc()
                 self.tx.rollback_savepoint(sp, cursor=self.cursor())
                 return default
             self.tx.release_savepoint(sp, cursor=self.cursor())

{velocity_python-0.0.84 → velocity_python-0.0.86}/src/velocity/db/core/engine.py

@@ -6,6 +6,11 @@ from functools import wraps
 from velocity.db import exceptions
 from velocity.db.core.transaction import Transaction
 
+import logging
+
+logger = logging.getLogger("velocity.db.engine")
+logger.setLevel(logging.INFO)  # Or DEBUG for more verbosity
+
 
 class Engine:
     """
@@ -14,10 +19,11 @@ class Engine:
 
     MAX_RETRIES = 100
 
-    def __init__(self, driver, config, sql):
+    def __init__(self, driver, config, sql, connect_timeout=5):
         self.__config = config
         self.__sql = sql
         self.__driver = driver
+        self.__connect_timeout = connect_timeout
 
     def __str__(self):
         return f"[{self.sql.server}] engine({self.config})"
@@ -39,16 +45,52 @@ class Engine:
     def __connect(self):
         """
         Internal connection logic, raising suitable exceptions on error.
+        Enforces a connect timeout and handles different config types.
         """
+        server = self.sql.server.lower()
+        timeout_key = "timeout" if "sqlite" in server else "connect_timeout"
+        timeout_val = self.__connect_timeout
+
         try:
             if isinstance(self.config, dict):
-                return self.driver.connect(**self.config)
-            if isinstance(self.config, (tuple, list)):
-                return self.driver.connect(*self.config)
-            if isinstance(self.config, str):
-                return self.driver.connect(self.config)
-            raise Exception("Unhandled configuration parameter.")
-        except:
+                config = self.config.copy()
+                if timeout_key not in config:
+                    config[timeout_key] = timeout_val
+                logger.info(
+                    "Connecting to %s with dict config: %s", self.sql.server, config
+                )
+                return self.driver.connect(**config)
+
+            elif isinstance(self.config, str):
+                conn_str = self.config
+                if timeout_key not in conn_str:
+                    conn_str += f" {timeout_key}={timeout_val}"
+                logger.info(
+                    "Connecting to %s with str config: %s", self.sql.server, conn_str
+                )
+                return self.driver.connect(conn_str)
+
+            elif isinstance(self.config, (tuple, list)):
+                config_args = list(self.config)
+                if config_args and isinstance(config_args[-1], dict):
+                    if timeout_key not in config_args[-1]:
+                        config_args[-1][timeout_key] = timeout_val
+                else:
+                    config_args.append({timeout_key: timeout_val})
+
+                logger.info(
+                    "Connecting to %s with tuple/list config (with timeout): %s",
+                    self.sql.server,
+                    config_args,
+                )
+                return self.driver.connect(*config_args)
+
+            else:
+                raise TypeError(
+                    f"Unhandled configuration parameter type: {type(self.config)}"
+                )
+
+        except Exception:
             self.process_error()
 
     def transaction(self, func_or_cls=None):
@@ -307,67 +349,69 @@ class Engine:
 
         error_code, error_mesg = self.sql.get_error(e)
 
+        logger.warning(
+            "Database error caught. Attempting to transform: code=%s message=%s",
+            error_code,
+            error_mesg,
+        )
+
         if error_code in self.sql.ApplicationErrorCodes:
-            raise exceptions.DbApplicationError(e)
+            raise exceptions.DbApplicationError from None
         if error_code in self.sql.ColumnMissingErrorCodes:
-            raise exceptions.DbColumnMissingError(e)
+            raise exceptions.DbColumnMissingError from None
         if error_code in self.sql.TableMissingErrorCodes:
-            raise exceptions.DbTableMissingError(e)
+            raise exceptions.DbTableMissingError from None
         if error_code in self.sql.DatabaseMissingErrorCodes:
-            raise exceptions.DbDatabaseMissingError(e)
+            raise exceptions.DbDatabaseMissingError from None
         if error_code in self.sql.ForeignKeyMissingErrorCodes:
-            raise exceptions.DbForeignKeyMissingError(e)
+            raise exceptions.DbForeignKeyMissingError from None
         if error_code in self.sql.TruncationErrorCodes:
-            raise exceptions.DbTruncationError(e)
+            raise exceptions.DbTruncationError from None
         if error_code in self.sql.DataIntegrityErrorCodes:
-            raise exceptions.DbDataIntegrityError(e)
+            raise exceptions.DbDataIntegrityError from None
         if error_code in self.sql.ConnectionErrorCodes:
-            raise exceptions.DbConnectionError(e)
+            raise exceptions.DbConnectionError from None
         if error_code in self.sql.DuplicateKeyErrorCodes:
-            raise exceptions.DbDuplicateKeyError(e)
+            raise exceptions.DbDuplicateKeyError from None
         if re.search(r"key \(sys_id\)=\(\d+\) already exists.", msg, re.M):
-            raise exceptions.DbDuplicateKeyError(e)
+            raise exceptions.DbDuplicateKeyError from None
         if error_code in self.sql.DatabaseObjectExistsErrorCodes:
-            raise exceptions.DbObjectExistsError(e)
+            raise exceptions.DbObjectExistsError from None
         if error_code in self.sql.LockTimeoutErrorCodes:
-            raise exceptions.DbLockTimeoutError(e)
+            raise exceptions.DbLockTimeoutError from None
         if error_code in self.sql.RetryTransactionCodes:
-            raise exceptions.DbRetryTransaction(e)
+            raise exceptions.DbRetryTransaction from None
         if re.findall(r"database.*does not exist", msg, re.M):
-            raise exceptions.DbDatabaseMissingError(e)
+            raise exceptions.DbDatabaseMissingError from None
         if re.findall(r"no such database", msg, re.M):
-            raise exceptions.DbDatabaseMissingError(e)
+            raise exceptions.DbDatabaseMissingError from None
         if re.findall(r"already exists", msg, re.M):
-            raise exceptions.DbObjectExistsError(e)
+            raise exceptions.DbObjectExistsError from None
         if re.findall(r"server closed the connection unexpectedly", msg, re.M):
-            raise exceptions.DbConnectionError(e)
+            raise exceptions.DbConnectionError from None
         if re.findall(r"no connection to the server", msg, re.M):
-            raise exceptions.DbConnectionError(e)
+            raise exceptions.DbConnectionError from None
         if re.findall(r"connection timed out", msg, re.M):
-            raise exceptions.DbConnectionError(e)
+            raise exceptions.DbConnectionError from None
         if re.findall(r"could not connect to server", msg, re.M):
-            raise exceptions.DbConnectionError(e)
+            raise exceptions.DbConnectionError from None
         if re.findall(r"cannot connect to server", msg, re.M):
-            raise exceptions.DbConnectionError(e)
+            raise exceptions.DbConnectionError from None
         if re.findall(r"connection already closed", msg, re.M):
-            raise exceptions.DbConnectionError(e)
+            raise exceptions.DbConnectionError from None
         if re.findall(r"cursor already closed", msg, re.M):
-            raise exceptions.DbConnectionError(e)
+            raise exceptions.DbConnectionError from None
         if "no such table:" in msg:
-            raise exceptions.DbTableMissingError(e)
-
-        msg = f"""
-Unhandled/Unknown Error in engine.process_error
-EXC_TYPE = {type(e)}
-EXC_MSG = {str(e).strip()}
-
-ERROR_CODE = {error_code}
-ERROR_MSG = {error_mesg}
-
-SQL_STMT = {sql_stmt}
-SQL_PARAMS = {sql_params}
-
-{traceback.format_exc()}
-"""
-        print(msg)
+            raise exceptions.DbTableMissingError from None
+
+        logger.error(
+            "Unhandled/Unknown Error in engine.process_error",
+            exc_info=True,
+            extra={
+                "error_code": error_code,
+                "error_msg": error_mesg,
+                "sql_stmt": sql_stmt,
+                "sql_params": sql_params,
+            },
+        )
         raise

{velocity_python-0.0.84 → velocity_python-0.0.86}/src/velocity/db/core/table.py

@@ -661,6 +661,7 @@ class Table:
             return sql, vals
         return self.tx.execute(sql, vals, cursor=self.cursor()).one()
 
+    @return_default(0)
     def delete(self, where, **kwds):
         """
         Deletes rows matching `where`. Raises Exception if `where` is falsy.

{velocity_python-0.0.84 → velocity_python-0.0.86/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.84
+Version: 0.0.86
 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.84 → velocity_python-0.0.86}/src/velocity_python.egg-info/SOURCES.txt

@@ -2,6 +2,11 @@ LICENSE
 README.md
 pyproject.toml
 src/velocity/__init__.py
+src/velocity/app/__init__.py
+src/velocity/app/invoices.py
+src/velocity/app/orders.py
+src/velocity/app/payments.py
+src/velocity/app/purchase_orders.py
 src/velocity/aws/__init__.py
 src/velocity/aws/amplify.py
 src/velocity/aws/handlers/__init__.py