velocity-python 0.1.123__tar.gz → 0.1.125__tar.gz

{velocity_python-0.1.123 → velocity_python-0.1.125}/PKG-INFO

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

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

{velocity_python-0.1.123 → velocity_python-0.1.125}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.123"
+__version__ = version = "0.1.125"
 
 import importlib as _importlib
 

{velocity_python-0.1.123 → velocity_python-0.1.125}/src/velocity/aws/facets.py

@@ -34,6 +34,9 @@ Facets AND together; the values of one facet OR together. Kinds:
 ``since``     a period ending now: ``today``, ``Nd`` (``7d``, ``30d`` …, up to
               3660 days), ``year`` (this calendar year). Evaluated in the
               database's session time zone.
+``before``    strictly before a day (``YYYY-MM-DD``) or older than a period
+              (``Nd``): ``{"field": "sys_created", "kind": "before", "value":
+              "2026-09-01"}``. With ``since`` it brackets a range.
 ``text``      a write-in, case-insensitive, against ``field::text``:
               ``match`` is ``contains`` (default), ``equals``, ``starts`` or
               ``words`` — every whitespace-separated word of the term must
@@ -72,7 +75,7 @@ from velocity.db.servers.tablehelper import TableHelper
 
 PARAM_KEY = "facets"
 
-KINDS = ("values", "contains", "presence", "since", "text", "domain")
+KINDS = ("values", "contains", "presence", "since", "before", "text", "domain")
 MATCHES = ("contains", "equals", "starts", "words")
 PRESENCE = ("present", "absent")
 
@@ -199,6 +202,27 @@ def _kind_since(column: str, entry: Dict[str, Any], field: str) -> Optional[Pred
     return f"{column} >= now() - make_interval(days => %s)", (days,)
 
 
+_ISO_DATE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+
+
+def _kind_before(column: str, entry: Dict[str, Any], field: str) -> Optional[Predicate]:
+    """Rows strictly before a day (``YYYY-MM-DD``: anything earlier than that
+    day's midnight) or older than a period (``Nd``: before N days ago). The
+    complement of ``since`` — together they bracket a date range."""
+    value = _one(entry, field).lower()
+    if not value:
+        return None
+    if _ISO_DATE.match(value):
+        return f"{column} < %s::date", (value,)
+    match = _DAYS.match(value)
+    if not match:
+        raise FacetError(f"facet {field}: before must be YYYY-MM-DD or <N>d")
+    days = int(match.group(1))
+    if not 1 <= days <= MAX_DAYS:
+        raise FacetError(f"facet {field}: period must be 1 to {MAX_DAYS} days")
+    return f"{column} < now() - make_interval(days => %s)", (days,)
+
+
 def _columns(entry: Dict[str, Any], column: str, field: str) -> List[str]:
     """The column(s) a text facet matches: ``fields`` when given, else the field."""
     fields = entry.get("fields")
@@ -282,6 +306,7 @@ _BUILDERS = {
     "contains": _kind_contains,
     "presence": _kind_presence,
     "since": _kind_since,
+    "before": _kind_before,
     "text": _kind_text,
     "domain": _kind_domain,
 }

{velocity_python-0.1.123 → velocity_python-0.1.125}/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.123 → velocity_python-0.1.125}/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.123 → velocity_python-0.1.125}/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.123 → velocity_python-0.1.125}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.123
+Version: 0.1.125
 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.123 → velocity_python-0.1.125}/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.123 → velocity_python-0.1.125}/tests/test_facets.py

@@ -47,6 +47,34 @@ def test_presence_treats_null_and_empty_alike_for_any_column_type():
         facets.predicate({"field": "x", "kind": "presence", "value": "maybe"})
 
 
+def test_before_day_or_period():
+    assert facets.predicate(
+        {"field": "sys_created", "kind": "before", "value": "2026-09-01"}
+    ) == ("sys_created < %s::date", ("2026-09-01",))
+    assert facets.predicate(
+        {"field": "sys_created", "kind": "before", "value": "30d"}
+    ) == ("sys_created < now() - make_interval(days => %s)", (30,))
+    assert (
+        facets.predicate({"field": "sys_created", "kind": "before", "value": ""})
+        is None
+    )
+    for bad in ("2026-9-1", "yesterday", "0d", "9999d", "2026-09-01; drop"):
+        with pytest.raises(facets.FacetError):
+            facets.predicate({"field": "sys_created", "kind": "before", "value": bad})
+
+
+def test_since_and_before_bracket_a_range():
+    sql, params = facets.build_where(
+        [
+            {"field": "sys_created", "kind": "since", "value": "60d"},
+            {"field": "sys_created", "kind": "before", "value": "2026-09-01"},
+        ]
+    )
+    assert "sys_created >= now() - make_interval(days => %s)" in sql
+    assert "sys_created < %s::date" in sql
+    assert params == (60, "2026-09-01")
+
+
 def test_since_periods():
     assert facets.predicate(
         {"field": "internal_date", "kind": "since", "value": "today"}
@@ -173,7 +201,10 @@ def test_domain_refuses_an_address_or_whitespace_and_ignores_blanks():
     for bad in ("user@example.com", "two words.com", "a\tb.com"):
         with pytest.raises(facets.FacetError):
             facets.predicate({"field": "d", "kind": "domain", "values": [bad]})
-    assert facets.predicate({"field": "d", "kind": "domain", "values": ["", ".", "  "]}) is None
+    assert (
+        facets.predicate({"field": "d", "kind": "domain", "values": ["", ".", "  "]})
+        is None
+    )
 
 
 def test_exclude_negates_null_safely_for_any_kind():

velocity_python-0.1.125/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()