velocity-python 0.0.85__py3-none-any.whl → 0.0.87__py3-none-any.whl

velocity/__init__.py

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

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/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/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/db/core/table.py

@@ -286,6 +286,7 @@ class Table:
         if use_where:
             return Row(self, where, lock=lock)
         return Row(self, result[0]["sys_id"], lock=lock)
+    one=find
 
     @return_default(None)
     def first(
@@ -319,20 +320,6 @@ class Table:
             return Row(self, where, lock=lock)
         return Row(self, results[0]["sys_id"], lock=lock)
 
-    @return_default(None)
-    def one(self, where=None, orderby=None, lock=None, use_where=False):
-        """
-        Returns exactly one row matching `where`, or None if none found.
-        """
-        if isinstance(where, int):
-            where = {"sys_id": where}
-        results = self.select("sys_id", where=where, orderby=orderby).all()
-        if not results:
-            return None
-        if use_where:
-            return Row(self, where, lock=lock)
-        return Row(self, results[0]["sys_id"], lock=lock)
-
     def primary_keys(self):
         """
         Returns the list of primary key columns for this table.
@@ -661,6 +648,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.85.dist-info → velocity_python-0.0.87.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.85
+Version: 0.0.87
 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.85.dist-info → velocity_python-0.0.87.dist-info}/RECORD

@@ -1,4 +1,9 @@
-velocity/__init__.py,sha256=tTtkpSZbAfGaBwnRjv2rkzNo37CyxNfcIzY_OahBe0M,88
+velocity/__init__.py,sha256=ADiytoslPLwfK6AsSoQz6OBcwmKeojL4CaG-8UVv7Pc,106
+velocity/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+velocity/app/invoices.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+velocity/app/orders.py,sha256=W-HAXEwY8-IFXbKh82HnMeRVZM7P-TWGEQOWtkLIzI4,6298
+velocity/app/payments.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+velocity/app/purchase_orders.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/aws/__init__.py,sha256=tj9-NliYxRVPYLnnDuA4FMwBHbbH4ed8gtHgwRskNgY,647
 velocity/aws/amplify.py,sha256=PkFVmskwhm-ajAiwGg0QnSKlg1b_55d9WLdF-3-70aE,15102
 velocity/aws/handlers/__init__.py,sha256=xnpFZJVlC2uoeeFW4zuPST8wA8ajaQDky5Y6iXZzi3A,172
@@ -10,13 +15,13 @@ velocity/db/__init__.py,sha256=vrn2AFNAKaqTdnPwLFS0OcREcCtzUCOodlmH54U7ADg,200
 velocity/db/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/core/column.py,sha256=tAr8tL3a2nyaYpNHhGl508FrY_pGZTzyYgjAV5CEBv4,4092
 velocity/db/core/database.py,sha256=3zNGItklu9tZCKsbx2T2vCcU1so8AL9PPL0DLjvaz6s,3554
-velocity/db/core/decorators.py,sha256=ZwwNc6wGx7Qe7xPZGgeHuqqtXEeNqyDXB0M5ROY-40I,4612
-velocity/db/core/engine.py,sha256=NVsS9HPu13Lzuz7UHjUdsCRuBe2cYVKwgAVf9SLc1E0,13123
+velocity/db/core/decorators.py,sha256=76Jkr9XptXt8cvcgp1zbHfuL8uHzWy8lwfR29u-DVu4,4574
+velocity/db/core/engine.py,sha256=bDUBlUf_X897hU4Qgwd7mAm8lIoruu1CoC4LNKWK5Xc,15130
 velocity/db/core/exceptions.py,sha256=MOWyA1mlMe8eWbFkEHK0Lp9czdplpRyqbAn2JfGmMrM,707
 velocity/db/core/result.py,sha256=OVqoMwlx3CHNNwr-JGWRx5I8u_YX6hlUpecx99UT5nE,6164
 velocity/db/core/row.py,sha256=aliLYTTFirgJsOvmUsANwJMyxaATuhpGpFJhcu_twwY,6709
 velocity/db/core/sequence.py,sha256=VMBc0ZjGnOaWTwKW6xMNTdP8rZ2umQ8ml4fHTTwuGq4,3904
-velocity/db/core/table.py,sha256=1zI_GgkUCCjRmM30OGiLOgJnnAeJNkriK_mYeV34lC0,35058
+velocity/db/core/table.py,sha256=g2mq7_VzLBtxITAn47BbgMcUoJAy9XVP6ohzScNl_so,34573
 velocity/db/core/transaction.py,sha256=IQEmrHAjCg6hqxQQOpPLWUbyLXrTjIPGLHHv7P6urKU,6589
 velocity/db/servers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/servers/mysql.py,sha256=qHwlB_Mg02R7QFjD5QvJCorYYiP50CqEiQyZVl3uYns,20914
@@ -42,8 +47,8 @@ velocity/misc/tools.py,sha256=_bGneHHA_BV-kUonzw5H3hdJ5AOJRCKfzhgpkFbGqIo,1502
 velocity/misc/conv/__init__.py,sha256=MLYF58QHjzfDSxb1rdnmLnuEQCa3gnhzzZ30CwZVvQo,40
 velocity/misc/conv/iconv.py,sha256=d4_BucW8HTIkGNurJ7GWrtuptqUf-9t79ObzjJ5N76U,10603
 velocity/misc/conv/oconv.py,sha256=h5Lo05DqOQnxoD3y6Px_MQP_V-pBbWf8Hkgkb9Xp1jk,6032
-velocity_python-0.0.85.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.85.dist-info/METADATA,sha256=yGWLn5g87dSFiXk7jM5ys0VCykM-SS-BqBkG2qUz8kw,8586
-velocity_python-0.0.85.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-velocity_python-0.0.85.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.85.dist-info/RECORD,,
+velocity_python-0.0.87.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.87.dist-info/METADATA,sha256=MDcMH8szrQ4QLhGLftamZ1ALZFir0nstf6k5o_wtLzk,8586
+velocity_python-0.0.87.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+velocity_python-0.0.87.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.87.dist-info/RECORD,,