velocity-python 0.1.69__tar.gz → 0.1.71__tar.gz

{velocity_python-0.1.69 → velocity_python-0.1.71}/PKG-INFO

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

{velocity_python-0.1.69 → velocity_python-0.1.71}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.69"
+version = "0.1.71"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.69 → velocity_python-0.1.71}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.69"
+__version__ = version = "0.1.71"
 
 import importlib as _importlib
 

{velocity_python-0.1.69 → velocity_python-0.1.71}/src/velocity/db/core/column.py

@@ -15,6 +15,17 @@ class Column:
         self.name = name
         self.table = table
 
+    def cursor(self):
+        """
+        Return the active cursor for this column's transaction.
+
+        Required by the ``@return_default`` decorator, which brackets the wrapped
+        call in a savepoint (``create``/``rollback``/``release``) on ``self.cursor()``.
+        Delegates to the owning table so the savepoint shares the table's cursor —
+        the same one ``self.tx.execute`` runs the statement on.
+        """
+        return self.table.cursor()
+
     def __str__(self):
         return (
             f"Table: {self.table.name}\n"
@@ -113,6 +124,7 @@ class Column:
         Returns the distinct values in this column, optionally ordered and/or limited in quantity.
         """
         sql, vals = self.sql.select(
+            self.tx,
             columns=f"distinct {self.name}",
             table=self.table.name,
             orderby=f"{self.name} {order}",
@@ -127,7 +139,7 @@ class Column:
         try:
             qcol = self.sql.quote_identifier(self.name)
             sql, vals = self.sql.select(
-                columns=f"max({qcol})", table=self.table.name, where=where
+                self.tx, columns=f"max({qcol})", table=self.table.name, where=where
             )
             return self.tx.execute(sql, vals).scalar()
         except (exceptions.DbTableMissingError, exceptions.DbColumnMissingError):

{velocity_python-0.1.69 → velocity_python-0.1.71}/src/velocity/db/core/engine.py

@@ -548,10 +548,32 @@ class Engine:
                 if attr_name.startswith("__") and attr_name.endswith("__"):
                     continue
 
-                attr = getattr(func_or_cls, attr_name)
-
-                if callable(attr):
-                    setattr(NewCls, attr_name, self.transaction(attr))
+                # Inspect the attribute *as defined* (without triggering the
+                # descriptor) so that @staticmethod / @classmethod keep their
+                # nature. Plain getattr() resolves a staticmethod to its bare
+                # function; re-setting that as a class attribute turns it into an
+                # instance method, silently injecting `self` as the first
+                # positional arg and breaking every static/class method on the
+                # wrapped class. Wrap the underlying function but re-apply the
+                # original descriptor so the call signature is preserved.
+                raw = inspect.getattr_static(func_or_cls, attr_name, None)
+
+                if isinstance(raw, staticmethod):
+                    setattr(
+                        NewCls,
+                        attr_name,
+                        staticmethod(self.transaction(raw.__func__)),
+                    )
+                elif isinstance(raw, classmethod):
+                    setattr(
+                        NewCls,
+                        attr_name,
+                        classmethod(self.transaction(raw.__func__)),
+                    )
+                else:
+                    attr = getattr(func_or_cls, attr_name)
+                    if callable(attr):
+                        setattr(NewCls, attr_name, self.transaction(attr))
 
             return NewCls
 

{velocity_python-0.1.69 → velocity_python-0.1.71}/src/velocity_python.egg-info/PKG-INFO

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

{velocity_python-0.1.69 → velocity_python-0.1.71}/src/velocity_python.egg-info/SOURCES.txt

@@ -156,6 +156,7 @@ tests/test_asset_references.py
 tests/test_assets_service.py
 tests/test_async_support.py
 tests/test_batch_operations.py
+tests/test_column_tx_arg.py
 tests/test_concurrency_safety.py
 tests/test_connection_pool.py
 tests/test_connection_resilience.py
@@ -201,5 +202,6 @@ tests/test_sqs_per_record_transactions.py
 tests/test_ssm_config.py
 tests/test_sys_modified_count_postgres_demo.py
 tests/test_table_alter.py
+tests/test_transaction_class_wrapping.py
 tests/test_where_clause_validation.py
 tests/test_write_hook_create_flow.py

velocity_python-0.1.71/tests/test_column_tx_arg.py

@@ -0,0 +1,64 @@
+"""
+Regression tests for Column query methods staying in sync with the SQL builder.
+
+Two bugs these guard against:
+- ``Column`` lacked a ``cursor()`` method, so the ``@return_default`` decorator
+  (which brackets the call in a savepoint on ``self.cursor()``) raised
+  ``AttributeError: 'Column' object has no attribute 'cursor'``.
+- ``Column.distinct``/``Column.max`` called ``self.sql.select(columns=..., ...)``
+  without the leading ``tx`` positional the current ``SQL.select(tx, ...)``
+  signature requires, raising ``TypeError: ... missing 1 required positional
+  argument: 'tx'``.
+"""
+
+import unittest
+from unittest.mock import MagicMock
+
+
+def _make_column(name="class"):
+    from velocity.db.core.column import Column
+
+    tx = MagicMock()
+    tx.create_savepoint.return_value = "sp1"
+    result = MagicMock()
+    result.as_simple_list.return_value.all.return_value = ["a", "b"]
+    result.scalar.return_value = 5
+    tx.execute.return_value = result
+
+    sql = MagicMock()
+    sql.select.return_value = ("SELECT ...", [])
+    tx.engine.sql = sql
+
+    table = MagicMock()
+    table.tx = tx
+    table.name = "contact"
+    table.cursor.return_value = "CUR"
+
+    return Column(table, name), tx, sql, table
+
+
+class TestColumnCursorDelegation(unittest.TestCase):
+    def test_cursor_delegates_to_table(self):
+        col, _tx, _sql, table = _make_column()
+        self.assertEqual(col.cursor(), "CUR")
+        table.cursor.assert_called()
+
+
+class TestColumnSelectPassesTx(unittest.TestCase):
+    def test_distinct_passes_tx_first_and_returns_rows(self):
+        col, tx, sql, _table = _make_column()
+        result = col.distinct()
+        self.assertEqual(result, ["a", "b"])
+        args, _kwargs = sql.select.call_args
+        self.assertIs(args[0], tx, "distinct() must pass tx as the first positional arg")
+
+    def test_max_passes_tx_first_and_returns_scalar(self):
+        col, tx, sql, _table = _make_column()
+        result = col.max()
+        self.assertEqual(result, 5)
+        args, _kwargs = sql.select.call_args
+        self.assertIs(args[0], tx, "max() must pass tx as the first positional arg")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.1.71/tests/test_transaction_class_wrapping.py

@@ -0,0 +1,90 @@
+"""When @engine.transaction decorates a *class*, it re-wraps every method so
+each runs inside a transaction. That re-wrapping must preserve @staticmethod and
+@classmethod — otherwise the descriptor is stripped, the method becomes a plain
+instance method, and `self`/`cls` leaks in as the first positional argument.
+
+Regression: a stripped @staticmethod produced errors like
+  "HttpEventHandler._self_enroll_payload() takes 1 positional argument but 2 were given"
+and (when the first param was an int) "'X' object cannot be interpreted as an
+integer" via range(self). These methods declare no `tx` parameter, so the
+transaction wrapper calls straight through — no database needed for the test.
+"""
+
+import inspect
+from unittest.mock import MagicMock
+
+from velocity.db.core.engine import Engine
+
+
+def _engine():
+    driver = MagicMock()
+    sql = MagicMock()
+    sql.server = "PostgreSQL"
+    config = {"dbname": "d", "host": "h", "user": "u", "password": "p"}
+    return Engine(driver, config, sql, pool_enabled=False)
+
+
+def _make_wrapped_class():
+    engine = _engine()
+
+    @engine.transaction
+    class Handler:
+        marker = "instance"
+
+        def instance_method(self, value):
+            # Regular method: still receives self normally.
+            return (self.marker, value)
+
+        @staticmethod
+        def static_one_arg(value):
+            # Pre-fix: self leaked in -> "takes 1 positional arg but 2 given".
+            return value
+
+        @staticmethod
+        def static_int_default(attempts=3):
+            # Pre-fix: self bound to attempts -> range(self) blows up.
+            return list(range(attempts))
+
+        @classmethod
+        def class_method(cls, value):
+            return (cls.marker, value)
+
+    return Handler
+
+
+def test_staticmethod_called_via_instance_does_not_leak_self():
+    Handler = _make_wrapped_class()
+    h = Handler()
+    # The exact production call shapes that used to crash.
+    assert h.static_one_arg("payload") == "payload"
+    assert h.static_int_default() == [0, 1, 2]
+
+
+def test_staticmethod_called_via_class_does_not_leak_self():
+    Handler = _make_wrapped_class()
+    assert Handler.static_one_arg("payload") == "payload"
+    assert Handler.static_int_default(2) == [0, 1]
+
+
+def test_classmethod_preserved():
+    Handler = _make_wrapped_class()
+    assert Handler.class_method("x") == ("instance", "x")
+    assert Handler().class_method("y") == ("instance", "y")
+
+
+def test_instance_method_still_wrapped_and_receives_self():
+    Handler = _make_wrapped_class()
+    assert Handler().instance_method("v") == ("instance", "v")
+
+
+def test_descriptor_nature_is_actually_preserved():
+    # Not just behavior — the rebuilt attribute is genuinely a staticmethod /
+    # classmethod descriptor on the generated subclass, so the wrapping is
+    # transparent to anyone introspecting the class.
+    Handler = _make_wrapped_class()
+    assert isinstance(
+        inspect.getattr_static(Handler, "static_one_arg"), staticmethod
+    )
+    assert isinstance(
+        inspect.getattr_static(Handler, "class_method"), classmethod
+    )