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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.69
+Version: 0.1.70
 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.70}/pyproject.toml

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

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

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

{velocity_python-0.1.69 → velocity_python-0.1.70}/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.70}/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.70
 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.70}/src/velocity_python.egg-info/SOURCES.txt

@@ -201,5 +201,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.70/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
+    )