vgi-python 0.16.0__tar.gz → 0.17.0__tar.gz

{vgi_python-0.16.0 → vgi_python-0.17.0}/.github/workflows/integration.yml

@@ -32,7 +32,7 @@ env:
   VGI_REF: main
   # The Haybarn release providing the prebuilt haybarn-unittest binary. Must be
   # ABI-compatible with the community-published vgi extension.
-  HAYBARN_RELEASE: haybarn-v1.5.4-rc1
+  HAYBARN_RELEASE: haybarn-v1.5.4-rc3
 
 jobs:
   integration:

{vgi_python-0.16.0 → vgi_python-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vgi-python
-Version: 0.16.0
+Version: 0.17.0
 Summary: Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow
 Project-URL: Homepage, https://query.farm
 Project-URL: Repository, https://github.com/Query-farm/vgi-python
@@ -162,7 +162,7 @@ Requires-Dist: httpx>=0.24
 Requires-Dist: platformdirs
 Requires-Dist: pyarrow
 Requires-Dist: typer>=0.9
-Requires-Dist: vgi-rpc>=0.24.0
+Requires-Dist: vgi-rpc>=0.26.0
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.16.0; extra == 'azure'
 Requires-Dist: pymssql>=2.3.0; extra == 'azure'

{vgi_python-0.16.0 → vgi_python-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.16.0"
+version = "0.17.0"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [
@@ -40,7 +40,7 @@ dependencies = [
     "pyarrow",
     "typer>=0.9",
     "platformdirs",
-    "vgi-rpc>=0.24.0",
+    "vgi-rpc>=0.26.0",
     "httpx>=0.24",
 ]
 

{vgi_python-0.16.0 → vgi_python-0.17.0}/tests/landing/describe.expected.json

@@ -3,7 +3,7 @@
     {
       "attach_options": [],
       "counts": {
-        "functions": 188,
+        "functions": 207,
         "schemas": 2,
         "tables": 59,
         "views": 3
@@ -655,6 +655,63 @@
               "returns": "binary",
               "type": "scalar"
             },
+            {
+              "args": [
+                {
+                  "desc": "Value",
+                  "name": "value",
+                  "type": "int64"
+                },
+                {
+                  "desc": "Constant addend",
+                  "name": "addend",
+                  "type": "int64"
+                }
+              ],
+              "doc": "value + const addend (advertises vgi.cache.ttl)",
+              "name": "cached_add_const",
+              "returns": "int64",
+              "type": "scalar"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Value to double",
+                  "name": "value",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Doubles a BIGINT value (advertises vgi.cache.ttl for per-value memo)",
+              "name": "cached_double_scalar",
+              "returns": "int64",
+              "type": "scalar"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Value",
+                  "name": "value",
+                  "type": "int64"
+                }
+              ],
+              "doc": "value -> 'lbl-<value>' or NULL for negatives (advertises vgi.cache.ttl)",
+              "name": "cached_label",
+              "returns": "string",
+              "type": "scalar"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Positive integer",
+                  "name": "value",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Number of Collatz (3n+1) steps for each integer to reach 1",
+              "name": "collatz_steps",
+              "returns": "int64",
+              "type": "scalar"
+            },
             {
               "args": [
                 {
@@ -864,6 +921,24 @@
               "returns": "double",
               "type": "scalar"
             },
+            {
+              "args": [
+                {
+                  "desc": "String to stretch",
+                  "name": "value",
+                  "type": "string"
+                },
+                {
+                  "desc": "Number of SHA-256 rounds",
+                  "name": "rounds",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Apply SHA-256 `rounds` times (key-stretching); rounds is a const compute knob",
+              "name": "hash_rounds",
+              "returns": "string",
+              "type": "scalar"
+            },
             {
               "args": [
                 {
@@ -975,6 +1050,19 @@
               "returns": "string",
               "type": "scalar"
             },
+            {
+              "args": [
+                {
+                  "desc": "String value",
+                  "name": "value",
+                  "type": "string"
+                }
+              ],
+              "doc": "Returns the input string unchanged (zero-compute wire probe)",
+              "name": "passthru",
+              "returns": "string",
+              "type": "scalar"
+            },
             {
               "args": [
                 {
@@ -1051,6 +1139,19 @@
               "returns": "string",
               "type": "scalar"
             },
+            {
+              "args": [
+                {
+                  "desc": "String to hash",
+                  "name": "value",
+                  "type": "string"
+                }
+              ],
+              "doc": "Lowercase hex SHA-256 digest of the UTF-8 string",
+              "name": "sha256_hex",
+              "returns": "string",
+              "type": "scalar"
+            },
             {
               "args": [
                 {
@@ -1259,6 +1360,18 @@
               "name": "blended_drop",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Fan-out count: emit rows 0..n-1 for this input row",
+                  "name": "n",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Blended 1->N fan-out (emit 0..n-1 per input row) with row provenance",
+              "name": "blended_explode",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -1468,6 +1581,54 @@
               "name": "cache_parallel",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Rows per (region, year) partition",
+                  "name": "rows_per_partition",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Per-partition cacheable over (region, year) SINGLE_VALUE partition columns",
+              "name": "cache_partition_multicol",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Rows per country partition",
+                  "name": "rows_per_country",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Per-partition cacheable; work-queue fan-out (parallel capture); one NULL partition",
+              "name": "cache_partition_parallel",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Rows per country partition",
+                  "name": "rows_per_country",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Per-partition cacheable with projection pushdown + explicit partition_values",
+              "name": "cache_partition_proj",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Rows per country partition",
+                  "name": "rows_per_country",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Per-partition cacheable single-value-partitioned result (vgi.cache.partition_scope)",
+              "name": "cache_partition_scope",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -1563,6 +1724,42 @@
               "name": "cacheable_numbers",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Input column",
+                  "name": "x",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Cacheable blended map x -> x*2 (advertises vgi.cache.ttl)",
+              "name": "cached_double",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Cacheable classic (TABLE-input) passthrough (advertises vgi.cache.ttl)",
+              "name": "cached_echo",
+              "type": "table"
+            },
+            {
+              "args": [
+                {
+                  "desc": "Input column",
+                  "name": "x",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Blended map x->x*2 with always-revalidate (304 not_modified) contract",
+              "name": "cached_reval_double",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Classic passthrough with always-revalidate (304 not_modified) contract",
+              "name": "cached_reval_echo",
+              "type": "table"
+            },
             {
               "args": [],
               "doc": "Scan colors table (ENUM column)",
@@ -1885,6 +2082,25 @@
               "name": "geo_encode",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Input column (echoed as output)",
+                  "name": "x",
+                  "type": "int64"
+                },
+                {
+                  "default": "\"range\"",
+                  "desc": "range | length | base64",
+                  "name": "mode",
+                  "named": true,
+                  "type": "string"
+                }
+              ],
+              "doc": "Adversarial blended fixture emitting malformed vgi_rpc.parent_row",
+              "name": "hostile_provenance",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -2302,6 +2518,18 @@
               "name": "profiling_demo",
               "type": "table"
             },
+            {
+              "args": [
+                {
+                  "desc": "Input column",
+                  "name": "x",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Blended 1->1 map with projection_pushdown + two output columns",
+              "name": "projectable_blended",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -2815,6 +3043,20 @@
               "name": "buffer_input",
               "type": "table_in_out"
             },
+            {
+              "args": [
+                {
+                  "default": "false",
+                  "desc": "Whether to log during processing",
+                  "name": "logging",
+                  "named": true,
+                  "type": "bool"
+                }
+              ],
+              "doc": "Cacheable column-wise sum across all input (advertises vgi.cache.ttl)",
+              "name": "cached_sum_all",
+              "type": "table_in_out"
+            },
             {
               "args": [],
               "doc": "Worker raises during combine (test)",

{vgi_python-0.16.0 → vgi_python-0.17.0}/tests/test_filter_pushdown.py

@@ -1404,3 +1404,88 @@ class TestJoinKeysBatch:
         assert merged.num_columns == 2
         assert merged.column("a").to_pylist() == [1, 2, 3]
         assert merged.column("b").to_pylist() == [10, 20, 30]
+
+
+# =============================================================================
+# TestDegenerateConjunctions
+# =============================================================================
+
+
+class TestDegenerateConjunctions:
+    """An AND whose children all degrade must not render as `WHERE ()`.
+
+    `_parse_filter` returns None for a join-key filter whose keys column cannot
+    be resolved ("graceful degradation — DuckDB filters client-side"). Dropping
+    such a child from an AND is safe on its own, but when *every* child drops the
+    conjunction is left empty, and `f"({' AND '.join([])})"` yields `()` — which
+    reaches the backend as the syntactically invalid `... WHERE () LIMIT n`.
+    """
+
+    def _and_of_join_keys_batch(self) -> pa.RecordBatch:
+        """A filter spec of one AND whose only children are join-key filters.
+
+        No `join_keys` batches are supplied to `deserialize_filters`, so every
+        child resolves to None — the shape observed in production.
+        """
+        spec = json.dumps(
+            [
+                {
+                    "column_name": "trade_canceled",
+                    "column_index": 0,
+                    "type": "and",
+                    "children": [
+                        {
+                            "column_name": "trade_canceled",
+                            "column_index": 0,
+                            "type": "join_keys",
+                            "keys_column": "missing_keys_a",
+                        },
+                        {
+                            "column_name": "_partition_date",
+                            "column_index": 1,
+                            "type": "join_keys",
+                            "keys_column": "missing_keys_b",
+                        },
+                    ],
+                }
+            ]
+        )
+        s = pa.schema([pa.field("filter_spec", pa.string(), metadata={b"vgi_filter_version": b"1"})])
+        return pa.RecordBatch.from_pydict({"filter_spec": [spec]}, schema=s)
+
+    def test_and_with_all_children_dropped_yields_no_filter(self) -> None:
+        """All conjuncts unresolvable -> the AND is dropped entirely, not emptied."""
+        pf = deserialize_filters(self._and_of_join_keys_batch())
+        assert len(pf) == 0
+        assert pf.to_sql() == ("", [])
+
+    def test_and_with_all_children_dropped_never_emits_empty_parens(self) -> None:
+        """Regression: the rendered clause must never be the invalid `()`."""
+        where, params = deserialize_filters(self._and_of_join_keys_batch()).to_sql()
+        assert where != "()"
+        assert not params
+        # A caller appending `WHERE {where}` only when truthy must produce no WHERE.
+        assert not where
+
+    def test_empty_and_renders_as_true(self) -> None:
+        """An empty conjunction is AND's identity: it constrains nothing."""
+        f = AndFilter(column_name="c", column_index=0, children=())
+        assert _filter_to_sql(f, lambda s: f'"{s}"', "?", 0) == ("TRUE", [])
+        assert _filters(f).to_sql() == ("TRUE", [])
+
+    def test_empty_or_renders_as_false(self) -> None:
+        """An empty disjunction admits nothing — it must not widen the result set."""
+        f = OrFilter(column_name="c", column_index=0, children=())
+        assert _filter_to_sql(f, lambda s: f'"{s}"', "?", 0) == ("FALSE", [])
+        assert _filters(f).to_sql() == ("FALSE", [])
+
+    def test_and_keeps_resolvable_children(self) -> None:
+        """Partial degradation still yields a usable (weaker) conjunction."""
+        f = AndFilter(
+            column_name="c",
+            column_index=0,
+            children=(_eq("a", 0, 1), _eq("b", 1, 2)),
+        )
+        where, params = _filters(f).to_sql()
+        assert where == '("a" = ? AND "b" = ?)'
+        assert params == [1, 2]

{vgi_python-0.16.0 → vgi_python-0.17.0}/uv.lock

@@ -2228,7 +2228,7 @@ requires-dist = [
 
 [[package]]
 name = "vgi-python"
-version = "0.16.0"
+version = "0.17.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
@@ -2338,7 +2338,7 @@ requires-dist = [
     { name = "vgi-python", extras = ["test-fixtures"], marker = "extra == 'test-fixtures-writable'" },
     { name = "vgi-python", extras = ["test-fixtures", "test-fixtures-writable", "http", "oauth", "otel", "sentry", "azure"], marker = "extra == 'dev'" },
     { name = "vgi-python", extras = ["transactor"], marker = "extra == 'test-fixtures-writable'" },
-    { name = "vgi-rpc", specifier = ">=0.24.0" },
+    { name = "vgi-rpc", specifier = ">=0.26.0" },
     { name = "vgi-rpc", extras = ["conformance", "external", "http", "oauth", "otel", "sentry"], marker = "extra == 'dev'" },
     { name = "vgi-rpc", extras = ["http"], marker = "extra == 'http'" },
     { name = "vgi-rpc", extras = ["oauth"], marker = "extra == 'oauth'" },
@@ -2367,7 +2367,7 @@ docs = [
 
 [[package]]
 name = "vgi-rpc"
-version = "0.24.0"
+version = "0.26.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "docstring-parser" },
@@ -2375,9 +2375,9 @@ dependencies = [
     { name = "pywin32", marker = "sys_platform == 'win32'" },
     { name = "tzdata", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/63/53/d24648965748f26008dd71495e0330f536ce69f9ddffac431df25bbd3f78/vgi_rpc-0.24.0.tar.gz", hash = "sha256:dac1fd161c04a473f6c4309e94d18f22c8b1476d140be9a789ed710cf6339956", size = 860740, upload-time = "2026-07-09T21:35:44.26Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/51/86d4c4466cf5311e80db28f535c02b92961f3d5160a0aae348112a03f7d5/vgi_rpc-0.26.0.tar.gz", hash = "sha256:c0966c99e087f923b228b2211877a8695bf42052d9cde05ce9a4bf077047cb78", size = 869625, upload-time = "2026-07-21T17:39:12.871Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/13/1c/04654c95249e936bd027bb58abd0a36b3989c28b1e7aba891e9651eb0323/vgi_rpc-0.24.0-py3-none-any.whl", hash = "sha256:46caf719bc27b156cd30115c790e00c3ad67f3238ed51a7dc7dbe4dffe794391", size = 380110, upload-time = "2026-07-09T21:35:42.65Z" },
+    { url = "https://files.pythonhosted.org/packages/57/51/d86efc32aef03d69d197916f9d18d0f3719ebd843424cfb9a782ced041c9/vgi_rpc-0.26.0-py3-none-any.whl", hash = "sha256:2c455edb517831867342ce2f105386b73b1fa23137477916c5e5d7a14b66e0fc", size = 386786, upload-time = "2026-07-21T17:39:11.142Z" },
 ]
 
 [package.optional-dependencies]

{vgi_python-0.16.0 → vgi_python-0.17.0}/vgi/_test_fixtures/scalar/__init__.py

@@ -19,12 +19,21 @@ unchanged.
 
 from vgi._test_fixtures.scalar.arithmetic import (
     AddValuesFunction,
+    CachedAddConstScalarFunction,
+    CachedDoubleScalarFunction,
+    CachedLabelScalarFunction,
     ConcatValuesIntFunction,
     ConcatValuesStrFunction,
     DoubleFunction,
     MultiplyFunction,
     SumValuesFunction,
 )
+from vgi._test_fixtures.scalar.bench_ladder import (
+    CollatzStepsFunction,
+    HashRoundsFunction,
+    PassthruFunction,
+    Sha256HexFunction,
+)
 from vgi._test_fixtures.scalar.binary import (
     BinaryPacketFunction,
     UpperCaseFunction,
@@ -83,10 +92,17 @@ __all__ = [
     "AnyMixedStrFunction",
     "BernoulliFunction",
     "BinaryPacketFunction",
+    "CachedAddConstScalarFunction",
+    "CachedDoubleScalarFunction",
+    "CachedLabelScalarFunction",
+    "CollatzStepsFunction",
     "ConcatValuesIntFunction",
     "ConcatValuesStrFunction",
     "ConditionalMessageFunction",
     "DoubleFunction",
+    "HashRoundsFunction",
+    "PassthruFunction",
+    "Sha256HexFunction",
     "FormatNumberDefaultFunction",
     "FormatNumberFullFunction",
     "FormatNumberPrecisionFunction",

{vgi_python-0.16.0 → vgi_python-0.17.0}/vgi/_test_fixtures/scalar/arithmetic.py

@@ -11,6 +11,7 @@ import pyarrow.compute as pc
 
 from vgi._test_fixtures.scalar._common import _is_addable_type, _is_multipliable_type, _promote_for_addition
 from vgi.arguments import ConstParam, Param, Returns
+from vgi.cache_control import CacheControl
 from vgi.metadata import FunctionExample
 from vgi.scalar_function import BindParameters, BindResult, ScalarFunction
 
@@ -131,6 +132,82 @@ class DoubleFunction(ScalarFunction):
         return result
 
 
+class CachedDoubleScalarFunction(ScalarFunction):
+    """Doubles a BIGINT value and advertises vgi.cache.* — backs scalar per-value memo tests.
+
+    A deterministic 1:1 map, so opting into the result cache is sound: the extension
+    memoizes the output per distinct input value and serves a fully-warm distinct set
+    without the worker.
+    """
+
+    # Opt into the result cache (per-value memoization on the C++ side).
+    CACHE_CONTROL = CacheControl(ttl=300)
+
+    class Meta:
+        """Function metadata."""
+
+        name = "cached_double_scalar"
+        description = "Doubles a BIGINT value (advertises vgi.cache.ttl for per-value memo)"
+
+    @classmethod
+    def compute(
+        cls,
+        value: Annotated[pa.Int64Array, Param(doc="Value to double")],
+    ) -> Annotated[pa.Int64Array, Returns(pa.int64())]:
+        """Double the input values."""
+        return pc.multiply(value, 2)
+
+
+class CachedAddConstScalarFunction(ScalarFunction):
+    """value + addend (a CONST param), cacheable — backs per-value const-param keying tests.
+
+    Two calls with the same ``value`` but different ``addend`` must NOT cross-serve: the
+    const arg is folded into the cache key.
+    """
+
+    CACHE_CONTROL = CacheControl(ttl=300)
+
+    class Meta:
+        """Function metadata."""
+
+        name = "cached_add_const"
+        description = "value + const addend (advertises vgi.cache.ttl)"
+
+    @classmethod
+    def compute(
+        cls,
+        value: Annotated[pa.Int64Array, Param(doc="Value")],
+        addend: Annotated[pa.Int64Scalar, ConstParam("Constant addend")],
+    ) -> Annotated[pa.Int64Array, Returns(pa.int64())]:
+        """Add the const addend to each value."""
+        return pc.add(value, addend)
+
+
+class CachedLabelScalarFunction(ScalarFunction):
+    """VARCHAR output with NULLs, cacheable — exercises string/null round-trip through the cache.
+
+    Returns ``lbl-<value>`` for value >= 0, NULL otherwise, so a cached per-value entry must
+    round-trip both a heap string and a null.
+    """
+
+    CACHE_CONTROL = CacheControl(ttl=300)
+
+    class Meta:
+        """Function metadata."""
+
+        name = "cached_label"
+        description = "value -> 'lbl-<value>' or NULL for negatives (advertises vgi.cache.ttl)"
+
+    @classmethod
+    def compute(
+        cls,
+        value: Annotated[pa.Int64Array, Param(doc="Value")],
+    ) -> Annotated[pa.StringArray, Returns(pa.string())]:
+        """Label non-negative values; NULL for negatives."""
+        labels = ["lbl-" + str(v.as_py()) if (v.is_valid and v.as_py() >= 0) else None for v in value]
+        return pa.array(labels, type=pa.string())
+
+
 class AddValuesFunction(ScalarFunction):
     """Adds two numeric values together.