velocity-python 0.0.155__py3-none-any.whl → 0.0.161__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.155"
+__version__ = version = "0.0.161"
 
 from . import aws
 from . import db

velocity/aws/handlers/context.py

@@ -1,3 +1,4 @@
+import json
 import os
 import boto3
 import uuid
@@ -24,6 +25,8 @@ class Context:
         self.__aws_event = aws_event
         self.__aws_context = aws_context
         self.__log = log
+        self._job_record_cache = {}
+        self._job_cancelled_flag = False
 
     def postdata(self, keys=-1, default=None):
         if keys == -1:
@@ -87,9 +90,9 @@ class Context:
         if self.postdata("job_id"):
             # Sanitize data before storing in database
             sanitized_data = self._sanitize_job_data(data)
-            tx.table("aws_job_activity").update(
-                sanitized_data, {"job_id": self.postdata("job_id")}
-            )
+            job_id = self.postdata("job_id")
+            tx.table("aws_job_activity").update(sanitized_data, {"job_id": job_id})
+            self._job_record_cache.pop(job_id, None)
             tx.commit()
 
     def create_job(self, tx, job_data=None):
@@ -98,6 +101,9 @@ class Context:
             return
         sanitized_data = self._sanitize_job_data(job_data)
         tx.table("aws_job_activity").insert(sanitized_data)
+        job_id = sanitized_data.get("job_id")
+        if job_id:
+            self._job_record_cache.pop(job_id, None)
         tx.commit()
 
     def _sanitize_job_data(self, data):
@@ -183,6 +189,84 @@ class Context:
 
         return sanitized
 
+    def _get_job_record(self, tx, job_id=None, refresh=False):
+        job_id = job_id or self.postdata("job_id")
+        if not job_id:
+            return None
+
+        if refresh or job_id not in self._job_record_cache:
+            record = tx.table("aws_job_activity").find({"job_id": job_id})
+            if record is not None:
+                self._job_record_cache[job_id] = record
+            elif job_id in self._job_record_cache:
+                del self._job_record_cache[job_id]
+
+        return self._job_record_cache.get(job_id)
+
+    def is_job_cancel_requested(self, tx, force_refresh=False):
+        job = self._get_job_record(tx, refresh=force_refresh)
+        if not job:
+            return False
+
+        status = (job.get("status") or "").lower()
+        if status in {"cancelrequested", "cancelled"}:
+            return True
+
+        message_raw = job.get("message")
+        if not message_raw:
+            return False
+
+        if isinstance(message_raw, dict):
+            message = message_raw
+        else:
+            try:
+                message = json.loads(message_raw)
+            except (TypeError, ValueError, json.JSONDecodeError):
+                return False
+
+        return bool(message.get("cancel_requested") or message.get("cancelled"))
+
+    def mark_job_cancelled(self, tx, detail=None, requested_by=None):
+        job_id = self.postdata("job_id")
+        if not job_id:
+            return
+
+        job = self._get_job_record(tx, refresh=True) or {}
+        message_raw = job.get("message")
+        if isinstance(message_raw, dict):
+            message = dict(message_raw)
+        else:
+            try:
+                message = json.loads(message_raw) if message_raw else {}
+            except (TypeError, ValueError, json.JSONDecodeError):
+                message = {}
+
+        message.update(
+            {
+                "detail": detail or "Job cancelled",
+                "cancelled": True,
+            }
+        )
+
+        tx.table("aws_job_activity").update(
+            {
+                "status": "Cancelled",
+                "message": to_json(message),
+                "handler_complete_timestamp": datetime.now(),
+                "sys_modified": datetime.now(),
+                "sys_modified_by": requested_by
+                or self.session().get("email_address")
+                or "system",
+            },
+            {"job_id": job_id},
+        )
+        tx.commit()
+        self._job_record_cache.pop(job_id, None)
+        self._job_cancelled_flag = True
+
+    def was_job_cancelled(self):
+        return self._job_cancelled_flag
+
     def enqueue(self, action, payload={}, user=None, suppress_job_activity=False):
         """
         Enqueue jobs to SQS with independent job activity tracking.

velocity/db/core/decorators.py

@@ -4,10 +4,27 @@ from functools import wraps
 from velocity.db import exceptions
 
 
+_PRIMARY_KEY_PATTERNS = (
+    "primary key",
+    "key 'primary'",
+    'key "primary"',
+)
+
+
+def _is_primary_key_duplicate(error):
+    """Return True when the duplicate-key error is targeting the primary key."""
+
+    message = str(error or "")
+    lowered = message.lower()
+
+    if "sys_id" in lowered:
+        return True
+
+    return any(pattern in lowered for pattern in _PRIMARY_KEY_PATTERNS)
+
+
 def retry_on_dup_key(func):
-    """
-    Retries a function call if it raises DbDuplicateKeyError, up to max_retries.
-    """
+    """Retry when insert/update fails because the primary key already exists."""
 
     @wraps(func)
     def retry_decorator(self, *args, **kwds):
@@ -19,10 +36,12 @@ def retry_on_dup_key(func):
                 result = func(self, *args, **kwds)
                 self.tx.release_savepoint(sp, cursor=self.cursor())
                 return result
-            except exceptions.DbDuplicateKeyError:
+            except exceptions.DbDuplicateKeyError as error:
                 self.tx.rollback_savepoint(sp, cursor=self.cursor())
                 if "sys_id" in kwds.get("data", {}):
                     raise
+                if not _is_primary_key_duplicate(error):
+                    raise
                 retries += 1
                 if retries >= max_retries:
                     raise
@@ -34,9 +53,7 @@ def retry_on_dup_key(func):
 
 
 def reset_id_on_dup_key(func):
-    """
-    Wraps an INSERT/UPSERT to reset the sys_id sequence on duplicate key collisions.
-    """
+    """Retry sys_id sequence bump only when the primary key collides."""
 
     @wraps(func)
     def reset_decorator(self, *args, retries=0, **kwds):
@@ -45,10 +62,12 @@ def reset_id_on_dup_key(func):
             result = func(self, *args, **kwds)
             self.tx.release_savepoint(sp, cursor=self.cursor())
             return result
-        except exceptions.DbDuplicateKeyError:
+        except exceptions.DbDuplicateKeyError as error:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())
             if "sys_id" in kwds.get("data", {}):
                 raise
+            if not _is_primary_key_duplicate(error):
+                raise
             if retries < 3:
                 backoff_time = (2**retries) * 0.01 + random.uniform(0, 0.02)
                 time.sleep(backoff_time)
@@ -128,7 +147,7 @@ def create_missing(func):
             for i, arg in enumerate(args):
                 if isinstance(arg, dict):
                     data.update(arg)
-            self.alter(data)
+            self.alter(data, mode="add")
             return func(self, *args, **kwds)
         except exceptions.DbTableMissingError as e:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())

velocity/db/core/engine.py

@@ -1,10 +1,10 @@
 import inspect
 import re
-import os
 from contextlib import contextmanager
 from functools import wraps
 from velocity.db import exceptions
 from velocity.db.core.transaction import Transaction
+from velocity.db.utils import mask_config_for_display
 
 import logging
 
@@ -27,7 +27,8 @@ class Engine:
         self.__schema_locked = schema_locked
 
     def __str__(self):
-        return f"[{self.sql.server}] engine({self.config})"
+        safe_config = mask_config_for_display(self.config)
+        return f"[{self.sql.server}] engine({safe_config})"
 
     def connect(self):
         """

velocity/db/core/result.py

@@ -349,7 +349,9 @@ class Result:
             return row
         except StopIteration:
             return default
-
+        
+    one_or_none = one
+    
     def get_table_data(self, headers=True):
         """
         Builds a two-dimensional list: first row is column headers, subsequent rows are data.

velocity/db/core/table.py

@@ -1,3 +1,4 @@
+import re
 import sqlparse
 from collections.abc import Iterable, Mapping
 from velocity.db import exceptions
@@ -38,6 +39,103 @@ SYSTEM_COLUMN_NAMES = (
 
 _SYSTEM_COLUMN_SET = {name.lower() for name in SYSTEM_COLUMN_NAMES}
 
+_NULLABLE_TRUE = {"YES", "TRUE", "T", "1", "Y"}
+_NULLABLE_FALSE = {"NO", "FALSE", "F", "0", "N"}
+
+
+def _normalize_sql_type(value):
+    """Return a simplified SQL type identifier for comparison purposes."""
+
+    if value is None:
+        return None
+
+    normalized = re.sub(r"\s+", " ", str(value).strip()).upper()
+
+    if not normalized:
+        return None
+
+    if normalized.startswith("CHARACTER VARYING") or normalized.startswith("VARCHAR"):
+        return "TEXT"
+    if normalized.startswith("CHAR(") or normalized == "CHARACTER" or normalized == "BPCHAR":
+        return "TEXT"
+    if normalized.startswith("NUMERIC(") or normalized.startswith("DECIMAL("):
+        return "NUMERIC"
+    if normalized == "TIMESTAMP":
+        return "TIMESTAMP WITHOUT TIME ZONE"
+    if normalized.startswith("TIMESTAMP WITHOUT TIME ZONE"):
+        return "TIMESTAMP WITHOUT TIME ZONE"
+    if normalized in {"TIMESTAMPTZ", "TIMESTAMP WITH TIME ZONE"}:
+        return "TIMESTAMP WITH TIME ZONE"
+    if normalized.startswith("TIME WITHOUT TIME ZONE"):
+        return "TIME WITHOUT TIME ZONE"
+    if normalized in {"TIME WITH TIME ZONE", "TIMETZ"}:
+        return "TIME WITH TIME ZONE"
+    if normalized == "BOOL":
+        return "BOOLEAN"
+    return normalized
+
+
+def _types_equivalent(current, expected):
+    return _normalize_sql_type(current) == _normalize_sql_type(expected)
+
+
+def _is_nullable_flag(value):
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return None
+    text = str(value).strip().upper()
+    if text in _NULLABLE_TRUE:
+        return True
+    if text in _NULLABLE_FALSE:
+        return False
+    return None
+
+
+def _parse_column_spec(spec, default_nullable):
+    """Normalize user-provided column specification into a common structure."""
+
+    nullable = default_nullable
+    nullable_specified = False
+    alter_sql = None
+    using_expression = None
+
+    base = spec
+    override_options = {}
+
+    if isinstance(spec, tuple) and len(spec) == 2 and isinstance(spec[1], Mapping):
+        base, override_options = spec
+
+    options = {}
+    if isinstance(base, Mapping):
+        options.update(base)
+        base = options.get("type", options.get("value"))
+
+    if override_options:
+        options.update(override_options)
+
+    type_hint = options.get("type", base)
+    if type_hint is None and "value" in options:
+        type_hint = options["value"]
+
+    add_value = options.get("add_value", options.get("value", type_hint))
+
+    if "nullable" in options:
+        nullable = bool(options["nullable"])
+        nullable_specified = True
+
+    alter_sql = options.get("sql")
+    using_expression = options.get("using")
+
+    return {
+        "type_hint": type_hint,
+        "add_value": add_value,
+        "nullable": nullable,
+        "nullable_specified": nullable_specified,
+        "alter_sql": alter_sql,
+        "using": using_expression,
+    }
+
 
 class Table:
     SYSTEM_COLUMNS = SYSTEM_COLUMN_NAMES
@@ -430,7 +528,7 @@ class Table:
             return Row(self, lookup, lock=lock)
         return Row(self, result[0]["sys_id"], lock=lock)
 
-    one = find
+    one = one_or_none = find
 
     @return_default(None)
     def first(
@@ -535,22 +633,128 @@ class Table:
     @create_missing
     def alter(self, columns, **kwds):
         """
-        Adds any missing columns (based on the provided dict) to the table.
+        Create or update columns so they match the supplied specification.
         """
+
         if not isinstance(columns, dict):
             raise Exception("Columns must be a dict.")
+
+        mode = kwds.pop("mode", "smart")
+        mode = (mode or "smart").lower()
+        if mode not in {"smart", "add"}:
+            raise ValueError(f"Unsupported alter mode: {mode}")
+
+        sql_only = kwds.get("sql_only", False)
+        default_nullable = kwds.get("null_allowed", True)
+
         columns = self.lower_keys(columns)
-        diff = []
-        for k in columns.keys():
-            if k not in self.sys_columns():
-                diff.append(k)
-        if diff:
-            newcols = {key: columns[key] for key in diff}
-            sql, vals = self.sql.alter_add(self.name, newcols)
-            if kwds.get("sql_only", False):
-                return sql, vals
+        existing_columns = {col.lower() for col in self.sys_columns()}
+
+        to_add = {}
+        add_specs = {}
+        statements = []
+        null_statements = []
+        type_statements = []
+        custom_statements = []
+
+        for column_name, raw_spec in columns.items():
+            spec = _parse_column_spec(raw_spec, default_nullable)
+
+            if column_name not in existing_columns:
+                to_add[column_name] = spec["add_value"]
+                add_specs[column_name] = spec
+                continue
+
+            if mode == "add":
+                continue
+
+            column_obj = self.column(column_name)
+            current_type = column_obj.sql_type
+            type_hint = spec["type_hint"]
+
+            if not (isinstance(type_hint, str) and type_hint.startswith("@@")) and type_hint is not None:
+                expected_type = self.sql.types.get_type(type_hint)
+                if expected_type and not _types_equivalent(current_type, expected_type):
+                    if spec["using"]:
+                        clause = f"TYPE {expected_type} USING {spec['using']}"
+                        sql, vals = self.sql.alter_column_by_sql(self.name, column_name, clause)
+                    else:
+                        nullable_flag = _is_nullable_flag(column_obj.is_nullable)
+                        if nullable_flag is None:
+                            nullable_flag = True
+                        server_name = getattr(self.sql, "server", "").lower()
+                        if server_name.startswith("postgre"):
+                            type_argument = type_hint
+                        else:
+                            type_argument = expected_type or type_hint
+                        sql, vals = self.sql.alter_column_by_type(
+                            self.name,
+                            column_name,
+                            type_argument,
+                            nullable_flag,
+                        )
+                    type_statements.append((sql, vals))
+
+            if spec["alter_sql"]:
+                sql, vals = self.sql.alter_column_by_sql(self.name, column_name, spec["alter_sql"])
+                custom_statements.append((sql, vals))
+
+            if spec["nullable_specified"]:
+                desired_nullable = spec["nullable"]
+                current_nullable = _is_nullable_flag(column_obj.is_nullable)
+                if desired_nullable and current_nullable is False:
+                    sql, vals = self.sql.alter_column_by_sql(
+                        self.name, column_name, "DROP NOT NULL"
+                    )
+                    null_statements.append((sql, vals))
+                elif not desired_nullable and current_nullable is True:
+                    sql, vals = self.sql.alter_column_by_sql(
+                        self.name, column_name, "SET NOT NULL"
+                    )
+                    null_statements.append((sql, vals))
+
+        if to_add:
+            sql, vals = self.sql.alter_add(self.name, to_add, default_nullable)
+            statements.append((sql, vals))
+
+            for column_name, spec in add_specs.items():
+                if spec["nullable_specified"] and not spec["nullable"] and default_nullable:
+                    sql, vals = self.sql.alter_column_by_sql(
+                        self.name, column_name, "SET NOT NULL"
+                    )
+                    null_statements.append((sql, vals))
+                elif spec["nullable_specified"] and spec["nullable"] and not default_nullable:
+                    sql, vals = self.sql.alter_column_by_sql(
+                        self.name, column_name, "DROP NOT NULL"
+                    )
+                    null_statements.append((sql, vals))
+
+        statements.extend(type_statements)
+        statements.extend(custom_statements)
+        statements.extend(null_statements)
+
+        if not statements:
+            return None
+
+        if sql_only:
+            if len(statements) == 1:
+                return statements[0]
+            return statements
+
+        for sql, vals in statements:
+            if not sql:
+                continue
             self.tx.execute(sql, vals, cursor=self.cursor())
 
+    def alter_add(self, columns, **kwds):
+        """
+        Add missing columns without modifying existing column definitions.
+        """
+
+        kwds = dict(kwds)
+        kwds["mode"] = "add"
+        return self.alter(columns, **kwds)
+
     @create_missing
     def alter_type(self, column, type_or_value, nullable=True, **kwds):
         """

velocity/db/core/transaction.py

@@ -6,6 +6,7 @@ from velocity.db.core.result import Result
 from velocity.db.core.column import Column
 from velocity.db.core.database import Database
 from velocity.db.core.sequence import Sequence
+from velocity.db.utils import mask_config_for_display
 from velocity.misc.db import randomword
 
 debug = False
@@ -22,10 +23,14 @@ class Transaction:
         self.__pg_types = {}
 
     def __str__(self):
-        c = self.engine.config
-        server = c.get("host", c.get("server"))
-        database = c.get("database")
-        return f"{self.engine.sql.server}.transaction({server}:{database})"
+        config = mask_config_for_display(self.engine.config)
+
+        if isinstance(config, dict):
+            server = config.get("host", config.get("server"))
+            database = config.get("database", config.get("dbname"))
+            return f"{self.engine.sql.server}.transaction({server}:{database})"
+
+        return f"{self.engine.sql.server}.transaction({config})"
 
     def __enter__(self):
         return self

velocity/db/tests/test_db_utils.py

@@ -11,6 +11,8 @@ from src.velocity.db.utils import (
     safe_sort_rows,
     group_by_fields,
     safe_sort_grouped_rows,
+    mask_config_for_display,
+    mask_sensitive_in_string,
 )
 
 
@@ -216,6 +218,53 @@ class TestDatabaseUtils(unittest.TestCase):
         expected = ["2024-06", "2024-12", None]
         self.assertEqual(exp_dates, expected)
 
+    def test_mask_config_for_display_redacts_direct_passwords(self):
+        """Ensure direct password/token fields are masked."""
+        config = {
+            "host": "db.local",
+            "password": "supersecret",
+            "token": "abc123",
+        }
+
+        masked = mask_config_for_display(config)
+
+        self.assertEqual(masked["host"], "db.local")
+        self.assertEqual(masked["password"], "*****")
+        self.assertEqual(masked["token"], "*****")
+
+    def test_mask_config_for_display_handles_nested_structures(self):
+        """Verify masking applies to nested dicts, lists, tuples, and DSN strings."""
+        config = {
+            "options": {
+                "passwd": "innersecret",
+                "hosts": [
+                    {"url": "postgresql://user:pwd@localhost/db"},
+                    ("token=xyz",),
+                ],
+            }
+        }
+
+        masked = mask_config_for_display(config)
+
+        self.assertEqual(masked["options"]["passwd"], "*****")
+        self.assertEqual(
+            masked["options"]["hosts"][0]["url"],
+            "postgresql://user:*****@localhost/db",
+        )
+        self.assertEqual(masked["options"]["hosts"][1][0], "token=*****")
+
+    def test_mask_sensitive_in_string_redacts_key_value_pairs(self):
+        """Key/value DSN parameters should be redacted."""
+        dsn = "host=db password=abc123;user=test"
+        masked = mask_sensitive_in_string(dsn)
+        self.assertEqual(masked, "host=db password=*****;user=test")
+
+    def test_mask_sensitive_in_string_redacts_url_credentials(self):
+        """URL style credentials should hide the password portion."""
+        url = "postgresql://user:secret@host/db"
+        masked = mask_sensitive_in_string(url)
+        self.assertEqual(masked, "postgresql://user:*****@host/db")
+
 
 if __name__ == "__main__":
     unittest.main()

velocity/db/utils.py

@@ -1,12 +1,75 @@
-"""
-Database utility functions for common operations.
+"""Utility helpers for velocity.db modules.
 
-This module provides utility functions to handle common database operations
-safely, including sorting with None values and other edge cases.
+This module provides helpers for redacting sensitive configuration values along
+with common collection utilities used across the velocity database codebase.
 """
 
+import re
 from typing import Any, Callable, List
 
+_SENSITIVE_KEYWORDS = {
+    "password",
+    "passwd",
+    "pwd",
+    "secret",
+    "token",
+    "apikey",
+    "api_key",
+}
+
+_SENSITIVE_PATTERNS = [
+    re.compile(r"(password\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(passwd\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(pwd\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(secret\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(token\s*=\s*)([^\s;]+)", re.IGNORECASE),
+    re.compile(r"(api[_-]?key\s*=\s*)([^\s;]+)", re.IGNORECASE),
+]
+
+_URL_CREDENTIAL_PATTERN = re.compile(r"(://[^:\s]+:)([^@/\s]+)")
+
+
+def mask_sensitive_in_string(value: str) -> str:
+    """Return ``value`` with credential-like substrings redacted."""
+
+    if not value:
+        return value
+
+    masked = value
+    for pattern in _SENSITIVE_PATTERNS:
+        masked = pattern.sub(lambda match: match.group(1) + "*****", masked)
+
+    return _URL_CREDENTIAL_PATTERN.sub(r"\1*****", masked)
+
+
+def mask_config_for_display(config: Any) -> Any:
+    """Return ``config`` with common secret fields masked for logging/str()."""
+
+    if isinstance(config, dict):
+        masked = {}
+        for key, value in config.items():
+            if isinstance(key, str) and _contains_sensitive_keyword(key):
+                masked[key] = "*****"
+            else:
+                masked[key] = mask_config_for_display(value)
+        return masked
+
+    if isinstance(config, tuple):
+        return tuple(mask_config_for_display(item) for item in config)
+
+    if isinstance(config, list):
+        return [mask_config_for_display(item) for item in config]
+
+    if isinstance(config, str):
+        return mask_sensitive_in_string(config)
+
+    return config
+
+
+def _contains_sensitive_keyword(key: str) -> bool:
+    lowered = key.lower()
+    return any(token in lowered for token in _SENSITIVE_KEYWORDS)
+
 
 def safe_sort_key_none_last(field_name: str) -> Callable[[dict], tuple]:
     """

{velocity_python-0.0.155.dist-info → velocity_python-0.0.161.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.155
+Version: 0.0.161
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.155.dist-info → velocity_python-0.0.161.dist-info}/RECORD

@@ -1,4 +1,4 @@
-velocity/__init__.py,sha256=yUa97y1Q9BlLpTAAGQNMYBYbhbmb3eOdhWrKFIbxfsg,147
+velocity/__init__.py,sha256=yQuGM3AN4czqhK3Leb3ndVePPePCWYzTSOPANqmAQf0,147
 velocity/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/invoices.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/orders.py,sha256=C7ewngMpO8nD3ul_82o4FhZBdRkWvJtnuEbEJUKDCno,6151
@@ -12,7 +12,7 @@ velocity/aws/__init__.py,sha256=0nEsX68Q4I7Z7ybECJnNWsC8QhWOijn4NpaFgyzyfXA,685
 velocity/aws/amplify.py,sha256=VgSgon0XxboIozz0tKyUohgLIigelhe4W7EH8kwbnLg,15330
 velocity/aws/handlers/__init__.py,sha256=4-NKj8dBzjYEdIlNdfm_Ip5mI0oOGcpjjBcMwU42yhQ,227
 velocity/aws/handlers/base_handler.py,sha256=bapdzWss5lXesoLPsVwJo9hQMZLdz7XOubo3sK70xC8,7960
-velocity/aws/handlers/context.py,sha256=0kPZ8y-XjmBZY5NcexynR5htnWYfF0nwM1n5UH-6c5w,8413
+velocity/aws/handlers/context.py,sha256=yL1oA8y6q0b1Vg3KUB0XWJ0hqnToScZuBXEHpWif8V0,11259
 velocity/aws/handlers/exceptions.py,sha256=i4wcB8ZSWUHglX2xnesDlWLsU9AMYU72cHCWRBDmjQ8,361
 velocity/aws/handlers/lambda_handler.py,sha256=0wa_CHyJOaI5RsHqB0Ae83-B-SwlKR0qkGUlc7jitQI,4427
 velocity/aws/handlers/response.py,sha256=s2Kw7yv5zAir1mEmfv6yBVIvRcRQ__xyryf1SrvtiRc,9317
@@ -28,17 +28,17 @@ velocity/aws/tests/test_lambda_handler_json_serialization.py,sha256=VuikDD_tbRbA
 velocity/aws/tests/test_response.py,sha256=sCg6qOSDWNncnmkuf4N3gO5fxQQ3PyFNMRsYy195nKo,6546
 velocity/db/__init__.py,sha256=7XRUHY2af0HL1jvL0SAMpxSe5a2Phbkm-YLJCvC1C_0,739
 velocity/db/exceptions.py,sha256=LbgYJfY2nCBu7tBC_U1BwdczypJ24S6CUyREG_N5gO0,2345
-velocity/db/utils.py,sha256=IoXeAL_0wZE15gbxlb2TtNdHzUSV9bIvw8jNkqjz38o,7020
+velocity/db/utils.py,sha256=qfnxN67B91pIXqMEp8mP5RuzFlBI20zwMMWBoHHO29g,8864
 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=quhjMoEmK_l2jF7jXyL5Fgv8uisIpBz34Au5d3U6UHs,5276
-velocity/db/core/engine.py,sha256=mNlaFPruHO935phKPVrsxZprGYUvxW-zp2sBcBZ-KCg,20666
-velocity/db/core/result.py,sha256=b0ie3yZAOj9S57x32uFFGKZ95zhImmZ0iXl0X1qYszc,12813
+velocity/db/core/decorators.py,sha256=j2IM063-ejDrIpNwwajxPawTs0A5-DU0-prbPYa4KTM,5816
+velocity/db/core/engine.py,sha256=84jz1taX-t4nqXN99kz9WyczpgsRLGFNnc_hpaCi3lE,20769
+velocity/db/core/result.py,sha256=mW4wQLSMkUF59VXgiAZz0XOGdHwPkd6r8ncSK2iATFk,12848
 velocity/db/core/row.py,sha256=GOWm-HEBPCBwdqMHMBRc41m0Hoht4vRVQLkvdogX1fU,7729
 velocity/db/core/sequence.py,sha256=VMBc0ZjGnOaWTwKW6xMNTdP8rZ2umQ8ml4fHTTwuGq4,3904
-velocity/db/core/table.py,sha256=7ywF5nNLMru8f2lqDOYsJJTbPW9-eJ-G9UOPCmQezTw,43356
-velocity/db/core/transaction.py,sha256=VrEp37b2d_rRDHKYYm-0D0BiVtYZVltM3zooer25Klg,6918
+velocity/db/core/table.py,sha256=x7D--wyiZjr_xlE5Ug_yp0fkzvkYqYrZMzca78bSrh8,50583
+velocity/db/core/transaction.py,sha256=LDwwAXk666sBdT4J01bvu3rAYfWwxvxVVQUBbQlX-hY,7155
 velocity/db/servers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/servers/tablehelper.py,sha256=Q48ObN5KD_U2sBP0GUcjaQjKeE4Hr351sPQirwQ0_1s,22163
 velocity/db/servers/base/__init__.py,sha256=5--XJUeEAm7O6Ns2C_ODCr5TjFhdAge-zApZCT0LGTQ,285
@@ -69,7 +69,7 @@ velocity/db/servers/sqlserver/types.py,sha256=FAODYEO137m-WugpM89f9bQN9q6S2cjjUa
 velocity/db/tests/__init__.py,sha256=7-hilWb43cKnSnCeXcjFG-6LpziN5k443IpsIvuevP0,24
 velocity/db/tests/common_db_test.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/tests/test_cursor_rowcount_fix.py,sha256=mZRL1SBb9Knh67CSFyvfwj_LAarE_ilfVwpQHW18Yy8,5507
-velocity/db/tests/test_db_utils.py,sha256=mSbEQXYKpWidX1FEnjrmt3q3K4ra0YTtQclrS46ufEE,8426
+velocity/db/tests/test_db_utils.py,sha256=UmBh2Bmz95GI6uYwEnilcz3gmuxPgLVpsj_6ekSnkWY,10297
 velocity/db/tests/test_postgres.py,sha256=NoBydNkGmXn8olXwva4C4sYV3cKzERd6Df0wHixxoyE,15554
 velocity/db/tests/test_postgres_unchanged.py,sha256=rNcy7S_HXazi_MjU8QjRZO4q8dULMeG4tg6eN-rPPz8,2998
 velocity/db/tests/test_process_error_robustness.py,sha256=CZr_co_o6PK7dejOr_gwdn0iKTzjWPTY5k-PwJ6oh9s,11361
@@ -122,8 +122,8 @@ velocity/misc/tests/test_merge.py,sha256=Vm5_jY5cVczw0hZF-3TYzmxFw81heJOJB-dvhCg
 velocity/misc/tests/test_oconv.py,sha256=fy4DwWGn_v486r2d_3ACpuBD-K1oOngNq1HJCGH7X-M,4694
 velocity/misc/tests/test_original_error.py,sha256=iWSd18tckOA54LoPQOGV5j9LAz2W-3_ZOwmyZ8-4YQc,1742
 velocity/misc/tests/test_timer.py,sha256=l9nrF84kHaFofvQYKInJmfoqC01wBhsUB18lVBgXCoo,2758
-velocity_python-0.0.155.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.155.dist-info/METADATA,sha256=yiZnixMBu97CS5ZFTVJ2FDUb_MkaxGPblXhV6ajNS8A,34266
-velocity_python-0.0.155.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-velocity_python-0.0.155.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.155.dist-info/RECORD,,
+velocity_python-0.0.161.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.161.dist-info/METADATA,sha256=g74KjjNchM3sz3UzhciMNOxZYIOSQhzXujp0KLKVczU,34266
+velocity_python-0.0.161.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+velocity_python-0.0.161.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.161.dist-info/RECORD,,