velocity-python 0.1.124__tar.gz → 0.1.126__tar.gz

{velocity_python-0.1.124 → velocity_python-0.1.126}/PKG-INFO

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

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

{velocity_python-0.1.124 → velocity_python-0.1.126}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.124"
+__version__ = version = "0.1.126"
 
 import importlib as _importlib
 

{velocity_python-0.1.124 → velocity_python-0.1.126}/src/velocity/aws/handlers/mixins/data_service.py

@@ -56,6 +56,39 @@ def _fk_blocked_delete_message(table, exc):
 _IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 
 
+TEXT_TYPES = frozenset(
+    {"text", "character varying", "character", "varchar", "char", "citext", "name"}
+)
+
+
+def coerce_empty_strings(column_types, incoming):
+    """The subset of ``incoming`` whose empty-string values must become
+    ``None`` because their column is not a text type — ``{}`` when nothing
+    needs changing or the types are unknown."""
+    if not column_types:
+        return {}
+    out = {}
+    for key, value in incoming.items():
+        if not isinstance(value, str) or value.strip() != "":
+            continue
+        dtype = column_types.get(key)
+        if dtype is None:
+            continue
+        if str(dtype).lower() in TEXT_TYPES:
+            continue
+        out[key] = None
+    return out
+
+
+def _column_types(tx, table):
+    """The table's ``{column: data_type}`` map, ``{}`` when unavailable —
+    a lookup failure must never block a write."""
+    try:
+        return tx.table(table).column_types(cache_ttl=300) or {}
+    except Exception:  # noqa: BLE001 — best effort, the write proceeds
+        return {}
+
+
 def _bump_sys_id_sequence(tx, table):
     """Keep the table's serial/identity sequence ahead of MAX(sys_id) so a
     future auto-generated id can never collide with an explicitly chosen one
@@ -338,6 +371,11 @@ class DataServiceMixin:
     def write_hook(self, tx, table, sys_id, incoming, context, save_as=False):
         row = {}
         incoming.pop("sys_id", None)
+        # A form posts every field it shows; untouched NULLs come back as ''.
+        # Postgres refuses '' for boolean/date/timestamp/numeric columns
+        # (found live: UPDATE studio SET inactive = '' — 2026-09-26), so
+        # empty strings become NULL wherever the column is not text.
+        incoming.update(coerce_empty_strings(_column_types(tx, table), incoming))
         if sys_id == "@new":
             self._call_rwx_hook(
                 "before_new", "common", tx, table, sys_id, incoming, context

{velocity_python-0.1.124 → velocity_python-0.1.126}/src/velocity/db/core/jsonproxy.py

@@ -68,6 +68,22 @@ class BoundList(list):
         super().__init__(_wrap(v, ctrl) for v in iterable)
         self._ctrl = ctrl
 
+    # -- copies are plain values ---------------------------------------
+    # A copy of a bound value is a plain list with no link to the row.
+    # Without these, copy.deepcopy rebuilt the proxy through the pickle
+    # path and refilled it with __setitem__ — one flush (an UPDATE) per
+    # nested container for a read-only copy, or an AttributeError when the
+    # rebuilt controller had no flush (2026-09-28, found by a dance forms
+    # migration deep-copying a definition read from a JSONB column).
+    def __copy__(self):
+        return unwrap(self)
+
+    def __deepcopy__(self, memo):
+        return unwrap(self)
+
+    def __reduce__(self):
+        return (list, (unwrap(self),))
+
     # -- mutators ------------------------------------------------------
     def __setitem__(self, index, value):
         if isinstance(index, slice):
@@ -131,6 +147,22 @@ class BoundDict(dict):
         super().__init__({k: _wrap(v, ctrl) for k, v in mapping.items()})
         self._ctrl = ctrl
 
+    # -- copies are plain values ---------------------------------------
+    # A copy of a bound value is a plain dict with no link to the row.
+    # Without these, copy.deepcopy rebuilt the proxy through the pickle
+    # path and refilled it with __setitem__ — one flush (an UPDATE) per
+    # nested container for a read-only copy, or an AttributeError when the
+    # rebuilt controller had no flush (2026-09-28, found by a dance forms
+    # migration deep-copying a definition read from a JSONB column).
+    def __copy__(self):
+        return unwrap(self)
+
+    def __deepcopy__(self, memo):
+        return unwrap(self)
+
+    def __reduce__(self):
+        return (dict, (unwrap(self),))
+
     # -- mutators ------------------------------------------------------
     def __setitem__(self, key, value):
         super().__setitem__(key, _wrap(value, self._ctrl))

{velocity_python-0.1.124 → velocity_python-0.1.126}/src/velocity/db/core/table.py

@@ -641,6 +641,36 @@ class Table:
             )
         return load()
 
+    def column_types(self, **kwds):
+        """``{column_name: data_type}`` (information_schema names, e.g.
+        ``boolean``, ``timestamp with time zone``, ``text``). ``{}`` when the
+        server module has no ``column_types`` SQL. ``cache_ttl=N`` as in
+        ``sys_columns``."""
+        builder = getattr(self.sql, "column_types", None)
+        if builder is None:
+            return {}
+        sql, vals = builder(self.name)
+        if kwds.get("sql_only", False):
+            return sql, vals
+
+        def load():
+            result = self.tx.execute(sql, vals, cursor=self.cursor())
+            return {name: dtype for name, dtype in result.as_tuple()}
+
+        cache_ttl = kwds.get("cache_ttl")
+        if cache_ttl:
+            from velocity.cache import SCHEMA_TAG, read_cache
+
+            return dict(
+                read_cache.memo(
+                    ("column_types", self._cache_scope(), self.name),
+                    load,
+                    cache_ttl,
+                    tables=(self.name, SCHEMA_TAG),
+                )
+            )
+        return load()
+
     def columns(self):
         """
         Returns non-system column names.

{velocity_python-0.1.124 → velocity_python-0.1.126}/src/velocity/db/servers/postgres/sql.py

@@ -1392,6 +1392,28 @@ class SQL(BaseSQLDialect):
                 ]
             )
 
+    @classmethod
+    def column_types(cls, name):
+        """``(column_name, data_type)`` rows for a table — the type map the
+        write path uses to turn a form's empty strings into NULL for
+        non-text columns."""
+        if "." in name:
+            return """
+            select column_name, data_type
+            from information_schema.columns
+            where UPPER(table_schema) = UPPER(%s)
+            and UPPER(table_name) = UPPER(%s)
+            """, tuple(
+                name.split(".")
+            )
+        return """
+            select column_name, data_type
+            from information_schema.columns
+            where UPPER(table_name) = UPPER(%s)
+            """, (
+            name,
+        )
+
     @classmethod
     def column_info(cls, table, name):
         params = table.split(".")

{velocity_python-0.1.124 → velocity_python-0.1.126}/src/velocity_python.egg-info/PKG-INFO

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

@@ -304,4 +304,5 @@ tests/test_transaction_class_wrapping.py
 tests/test_transaction_commit_and_ownership.py
 tests/test_transaction_edge_cases.py
 tests/test_where_clause_validation.py
-tests/test_write_hook_create_flow.py
+tests/test_write_hook_create_flow.py
+tests/test_write_hook_empty_strings.py

{velocity_python-0.1.124 → velocity_python-0.1.126}/tests/test_json_columns.py

@@ -423,3 +423,60 @@ class TestRowJsonTextDecode(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class TestProxyCopies(unittest.TestCase):
+    """A copy of a bound JSON value is a plain value: copying never
+    touches the row (2026-09-28)."""
+
+    def _bound(self):
+        from velocity.db.core import jsonproxy
+
+        writes = []
+        value = {
+            "pages": [{"ui": [{"copy": "x"}], "skippable": {"label": "s"}}],
+            "tags": ["a", ["b"]],
+        }
+        return jsonproxy.bind(value, writes.append), value, writes
+
+    def _assert_plain(self, value):
+        self.assertIn(type(value), (dict, list))
+        items = value.values() if isinstance(value, dict) else value
+        for item in items:
+            if isinstance(item, (dict, list)):
+                self._assert_plain(item)
+
+    def test_deepcopy_and_copy_are_plain_and_write_nothing(self):
+        import copy
+
+        bound, original, writes = self._bound()
+        deep = copy.deepcopy(bound)
+        shallow = copy.copy(bound)
+        self.assertEqual(deep, original)
+        self.assertEqual(shallow, original)
+        self._assert_plain(deep)
+        self._assert_plain(shallow)
+        self.assertEqual(writes, [])
+        # the copy is independent of the row
+        deep["pages"][0]["skippable"]["label"] = "changed"
+        self.assertEqual(bound["pages"][0]["skippable"]["label"], "s")
+        self.assertEqual(writes, [])
+        # nested proxies copy plain too
+        self._assert_plain(copy.deepcopy(bound["pages"]))
+        self._assert_plain(copy.copy(bound["tags"]))
+        self.assertEqual(writes, [])
+
+    def test_pickle_round_trip_is_plain(self):
+        import pickle
+
+        bound, original, writes = self._bound()
+        back = pickle.loads(pickle.dumps(bound))
+        self.assertEqual(back, original)
+        self._assert_plain(back)
+        self.assertEqual(writes, [])
+
+    def test_mutation_still_flushes(self):
+        bound, _original, writes = self._bound()
+        bound["pages"][0]["skippable"]["label"] = "t"
+        self.assertEqual(len(writes), 1)
+        self.assertEqual(writes[0]["pages"][0]["skippable"]["label"], "t")

velocity_python-0.1.126/tests/test_write_hook_empty_strings.py

@@ -0,0 +1,146 @@
+"""write_hook turns a form's empty strings into NULL for non-text columns
+(found live 2026-09-26: UPDATE studio SET inactive = '' — "invalid input
+syntax for type boolean"). Text columns keep '' (a cleared note is a note
+that is empty); unknown columns and unknown types are left alone.
+"""
+
+import importlib.util
+import unittest
+from pathlib import Path
+
+MODULE_PATH = (
+    Path(__file__).resolve().parents[1]
+    / "src"
+    / "velocity"
+    / "aws"
+    / "handlers"
+    / "mixins"
+    / "data_service.py"
+)
+_spec = importlib.util.spec_from_file_location("test_write_hook_empty", MODULE_PATH)
+_mod = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_mod)
+
+TYPES = {
+    "description": "text",
+    "notes": "character varying",
+    "inactive": "boolean",
+    "inactivated_on": "timestamp with time zone",
+    "start_date": "date",
+    "amount": "numeric",
+    "payload": "jsonb",
+}
+
+
+class CoerceTests(unittest.TestCase):
+    def test_empty_strings_become_null_for_non_text_columns(self):
+        incoming = {
+            "description": "Magnify 1",
+            "notes": "",
+            "inactive": "",
+            "inactivated_on": "  ",
+            "start_date": "",
+            "amount": "",
+            "payload": "",
+            "unknown_col": "",
+        }
+        self.assertEqual(
+            _mod.coerce_empty_strings(TYPES, incoming),
+            {
+                "inactive": None,
+                "inactivated_on": None,
+                "start_date": None,
+                "amount": None,
+                "payload": None,
+            },
+        )
+
+    def test_real_values_and_unknown_types_untouched(self):
+        self.assertEqual(
+            _mod.coerce_empty_strings(TYPES, {"inactive": False, "amount": "0"}), {}
+        )
+        self.assertEqual(_mod.coerce_empty_strings({}, {"inactive": ""}), {})
+        self.assertEqual(_mod.coerce_empty_strings(None, {"inactive": ""}), {})
+
+
+class FakeRow:
+    def __init__(self, data):
+        self.data = dict(data)
+        self.updates = []
+
+    def update(self, payload):
+        self.updates.append(dict(payload))
+        self.data.update(payload)
+
+    def to_dict(self):
+        return dict(self.data)
+
+    def __getitem__(self, k):
+        return self.data[k]
+
+
+class FakeTable:
+    def __init__(self, row, types):
+        self.row = row
+        self.types = types
+
+    def find(self, sys_id):
+        return self.row
+
+    def column_types(self, **kwds):
+        return self.types
+
+
+class FakeTx:
+    def __init__(self, table):
+        self._table = table
+
+    def table(self, name):
+        return self._table
+
+
+class FakeContext:
+    def get_feature_flags(self, tx):
+        return {}
+
+    def enqueue_dirty(self, table, sys_id):
+        pass
+
+
+class Service(_mod.DataServiceMixin):
+    def _call_rwx_hook(self, *args, **kwargs):
+        pass
+
+    def _get_dirty_pipeline_excluded_tables(self, tx, context):
+        return set()
+
+    def _dirty_pipeline_enabled(self, *a, **k):
+        return False
+
+
+class WriteHookTests(unittest.TestCase):
+    def test_update_writes_null_not_empty_string(self):
+        row = FakeRow({"sys_id": 6, "description": "Magnify", "inactive": None})
+        tx = FakeTx(FakeTable(row, TYPES))
+        incoming = {
+            "sys_id": 6,
+            "description": "Magnify 1",
+            "inactive": "",
+            "inactivated_on": "",
+            "inactivated_by": "",
+        }
+        try:
+            Service().write_hook(tx, "studio", 6, incoming, FakeContext())
+        except AttributeError:
+            # the tail of write_hook touches dirty-pipeline plumbing the fake
+            # does not model; the update itself has already happened
+            pass
+        self.assertEqual(row.updates[0]["inactive"], None)
+        self.assertEqual(row.updates[0]["inactivated_on"], None)
+        # a text column keeps its empty string
+        self.assertEqual(row.updates[0]["inactivated_by"], "")
+        self.assertEqual(row.updates[0]["description"], "Magnify 1")
+
+
+if __name__ == "__main__":
+    unittest.main()