vgi-python 0.8.8__tar.gz → 0.8.10__tar.gz

{vgi_python-0.8.8 → vgi_python-0.8.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vgi-python
-Version: 0.8.8
+Version: 0.8.10
 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
@@ -172,7 +172,6 @@ Requires-Dist: duckdb>=1.5.3; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
 Requires-Dist: numpy>=2.4.1; extra == 'dev'
 Requires-Dist: pyarrow-stubs; extra == 'dev'
-Requires-Dist: pydoclint; extra == 'dev'
 Requires-Dist: pymssql>=2.3.0; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'

{vgi_python-0.8.8 → vgi_python-0.8.10}/ci/run-integration.sh

@@ -133,12 +133,23 @@ trap cleanup EXIT
 # set BOOTED_PORT to the port it reports (PORT:<n>, the worker's readiness
 # contract). Sets a global rather than echoing so the backgrounded worker stays a
 # child of this shell (a $(...) subshell would reparent it and break teardown).
+#
+# The worker is spawned with cwd=$STAGE — the same directory the unittest binary
+# runs from below (`cd "$STAGE"`). copy_from/copy_to tests have DuckDB write a
+# source file under a relative `__TEST_DIR__` (duckdb_unittest_tempdir/...) that
+# the worker then opens by the same relative path; the worker only resolves it
+# if it shares DuckDB's cwd. On the stdio lane the C++ extension spawns the
+# worker as a subprocess that inherits DuckDB's cwd, so it matches for free; the
+# `( cd … ; exec … )` subshell gives the http worker the same footing (and
+# mirrors the vgi repo's run_http_integration.sh, which boots server and DuckDB
+# from one cwd). exec keeps the worker on the subshell's pid so teardown via the
+# captured `$!` still works.
 BOOTED_PORT=""
 boot_http_worker() {
   local exe="$1" log pid port=""
   BOOTED_PORT=""
   log="$(mktemp)"
-  "$exe" --http --port 0 >"$log" 2>&1 &
+  ( cd "$STAGE" && exec "$exe" --http --port 0 ) >"$log" 2>&1 &
   pid=$!
   echo "$pid" >> "$BG_PIDS_FILE"
   for _ in $(seq 1 60); do

{vgi_python-0.8.8 → vgi_python-0.8.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.8.8"
+version = "0.8.10"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [
@@ -77,7 +77,11 @@ dev = [
     "duckdb>=1.5.3",
     "mypy",
     "pyarrow-stubs",
-    "pydoclint",
+    # pydoclint is intentionally NOT a project dependency: it pulls
+    # docstring-parser-fork, which clobbers the canonical docstring-parser
+    # (a vgi-rpc dependency) in the shared `docstring_parser` namespace,
+    # non-deterministically breaking imports. tests/test_docstrings.py runs it
+    # in an isolated env via `uvx pydoclint` instead.
     "pytest",
     "pytest-cov",
     "pytest-examples",
@@ -142,7 +146,9 @@ quote-style = "double"
 # Docstring consistency gate (complements ruff's `D` rules, which only check
 # docstring *shape*, not whether documented args/attributes match the code).
 # Enforced families: DOC001 (parse), DOC101/102/103 (arg<->signature), DOC4xx
-# (yields), DOC60x (dataclass attributes). Run via `uv run pydoclint vgi/`.
+# (yields), DOC60x (dataclass attributes). pydoclint is NOT a project dependency
+# (it pulls docstring-parser-fork, which clobbers vgi-rpc's docstring-parser);
+# run it isolated: `uvx --python $(which python) pydoclint --config pyproject.toml vgi/`.
 style = "google"
 # We keep types in signatures, not docstrings (Google style) — so don't ask for
 # them in docstrings, and don't try to match return/yield *types* against prose.
@@ -162,7 +168,7 @@ allow_init_docstring = true
 # No baseline: vgi/ is fully clean under this config, so the gate enforces
 # every in-scope violation with no grandfathered exceptions. If a future change
 # needs to defer cleanup, freeze the current state and re-add `baseline`:
-#   uv run pydoclint --generate-baseline=True --baseline=.pydoclint-baseline vgi/
+#   uvx pydoclint --config pyproject.toml --generate-baseline=True --baseline=.pydoclint-baseline vgi/
 
 [tool.mypy]
 python_version = "3.13"

vgi_python-0.8.10/tests/test_docstrings.py

@@ -0,0 +1,65 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Docstring-consistency gate.
+
+Runs pydoclint over the ``vgi/`` package as part of the test suite. pydoclint
+complements ruff's ``D`` rules: ruff checks docstring *shape*, while pydoclint
+verifies that documented arguments, return values, yields, and dataclass
+attributes actually match the code. Configuration lives in ``[tool.pydoclint]``
+in ``pyproject.toml`` — this test invokes the same CLI, so there is no
+duplicated rule set.
+
+pydoclint runs through ``uvx`` (an isolated, ephemeral environment) rather than
+as a project dependency. It requires ``docstring-parser-fork`` while ``vgi-rpc``
+(a runtime dependency) requires the upstream ``docstring-parser``; both own the
+``docstring_parser`` import namespace, so installing pydoclint into the project
+env clobbers it non-deterministically and breaks unrelated imports (e.g.
+``conftest`` collection). Running via uvx keeps the fork out of the project tree.
+"""
+
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+_REPO_ROOT = Path(__file__).resolve().parents[1]
+
+# A real violation line looks like ``    42: DOC101: ...``. If pydoclint exits
+# non-zero without emitting any such code, it failed to *run* rather than finding
+# violations.
+_VIOLATION_RE = re.compile(r"\bDOC\d{3}\b")
+
+
+def test_pydoclint_clean() -> None:
+    """``vgi/`` must pass the pydoclint docstring gate (config in pyproject.toml)."""
+    uvx = shutil.which("uvx") or shutil.which("uv")
+    if uvx is None:  # pragma: no cover - uv is always present in dev/CI
+        pytest.skip("uv/uvx is not available to run pydoclint")
+
+    # `uvx pydoclint ...` == `uv tool run pydoclint ...`; both run pydoclint in an
+    # isolated env so docstring-parser-fork never enters the project tree.
+    # Pin the ephemeral env to *this* interpreter (``--python sys.executable``):
+    # pydoclint parses with its own runtime's AST, so it must run on a Python new
+    # enough for the repo's syntax (PEP 695 generics need 3.12+); uvx's default
+    # interpreter may be older and would report spurious DOC002 syntax errors.
+    base = [uvx] if Path(uvx).name == "uvx" else [uvx, "tool", "run"]
+    cmd = [*base, "--python", sys.executable, "pydoclint", "--config", "pyproject.toml", "vgi/"]
+    result = subprocess.run(cmd, cwd=_REPO_ROOT, capture_output=True, text=True)
+    output = result.stdout + result.stderr
+
+    if result.returncode == 0:
+        return
+
+    if not _VIOLATION_RE.search(output):  # pragma: no cover - env-dependent (e.g. offline uvx)
+        pytest.skip(f"pydoclint could not run via uvx:\n{output}")
+
+    pytest.fail(
+        "pydoclint found docstring violations:\n\n"
+        f"{output}\n"
+        "Fix the docstrings, or run `uvx pydoclint --config pyproject.toml "
+        "--generate-baseline=True --baseline=.pydoclint-baseline vgi/` "
+        "to defer them (see [tool.pydoclint] in pyproject.toml)."
+    )

{vgi_python-0.8.8 → vgi_python-0.8.10}/uv.lock

@@ -516,15 +516,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a7/5f/ed01f9a3cdffbd5a008556fc7b2a08ddb1cc6ace7effa7340604b1d16699/docstring_parser-0.18.0-py3-none-any.whl", hash = "sha256:b3fcbed555c47d8479be0796ef7e19c2670d428d72e96da63f3a40122860374b", size = 22484, upload-time = "2026-04-14T04:09:18.638Z" },
 ]
 
-[[package]]
-name = "docstring-parser-fork"
-version = "0.0.14"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/66/bf/27f9cab2f0cd1d17a4420572088bbc19f36d726fbcf165edf226a8926dbc/docstring_parser_fork-0.0.14.tar.gz", hash = "sha256:a2743a63d8d36c09650594f7b4ab5b2758fee8629dcf794d1b221b23179baa5c", size = 34551, upload-time = "2025-09-07T17:27:38.272Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/50/98b146aea0f1cd7531d25f12bea69fa9ce8d1662124f93fb30dc4511b65e/docstring_parser_fork-0.0.14-py3-none-any.whl", hash = "sha256:4c544f234ef2cc2749a3df32b70c437d77888b1099143a1ad5454452c574b9af", size = 43063, upload-time = "2025-09-07T17:27:37.012Z" },
-]
-
 [[package]]
 name = "duckdb"
 version = "1.5.4"
@@ -1657,19 +1648,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" },
 ]
 
-[[package]]
-name = "pydoclint"
-version = "0.8.7"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "docstring-parser-fork" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/bf/2e/e4df6b0cbb281cb6cf355f5d90b8c66939c7f3cd799c075fab23e0983dfb/pydoclint-0.8.7.tar.gz", hash = "sha256:1ce5055dfdaf2bc3c999d3ffd5494556b903b7090bb5fadac90819107f90629b", size = 199793, upload-time = "2026-06-22T01:24:20.117Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/d4/15fe5c3e66bbf3f60eb9c6ef7c2dca3931302f9acf317e65d70e7d8b338a/pydoclint-0.8.7-py3-none-any.whl", hash = "sha256:40f6b80e59129fe753f6a2f9edd76e4259c970eedc1ce3663adc43f54af439d3", size = 82963, upload-time = "2026-06-22T01:24:19.102Z" },
-]
-
 [[package]]
 name = "pygments"
 version = "2.20.0"
@@ -2250,7 +2228,7 @@ requires-dist = [
 
 [[package]]
 name = "vgi-python"
-version = "0.8.8"
+version = "0.8.10"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
@@ -2272,7 +2250,6 @@ dev = [
     { name = "mypy" },
     { name = "numpy" },
     { name = "pyarrow-stubs" },
-    { name = "pydoclint" },
     { name = "pymssql" },
     { name = "pytest" },
     { name = "pytest-cov" },
@@ -2346,7 +2323,6 @@ requires-dist = [
     { name = "platformdirs" },
     { name = "pyarrow" },
     { name = "pyarrow-stubs", marker = "extra == 'dev'" },
-    { name = "pydoclint", marker = "extra == 'dev'" },
     { name = "pymssql", marker = "extra == 'azure'", specifier = ">=2.3.0" },
     { name = "pytest", marker = "extra == 'dev'" },
     { name = "pytest-cov", marker = "extra == 'dev'" },

{vgi_python-0.8.8 → vgi_python-0.8.10}/vgi/_test_fixtures/copy_from.py

@@ -91,7 +91,7 @@ class ExampleLinesCopyFromFunction(CopyFromFunction[ExampleLinesCopyFromArgs]):
 
         # Column-major string arrays, NULL where the cell equals null_string,
         # then cast each column to the target type (DuckDB inserts no cast).
-        columns = list(zip(*rows)) if rows else [() for _ in range(ncols)]
+        columns = list(zip(*rows, strict=True)) if rows else [() for _ in range(ncols)]
         arrays = []
         for idx, field in enumerate(expected_schema):
             raw = [None if v == options.null_string else v for v in columns[idx]]

{vgi_python-0.8.8 → vgi_python-0.8.10}/vgi/_test_fixtures/scalar/arithmetic.py

@@ -51,9 +51,17 @@ class MultiplyFunction(ScalarFunction):
     def compute(
         cls,
         value: Annotated[pa.Int64Array, Param(doc="Integer value to multiply")],
-        factor: Annotated[int, ConstParam("Multiplication factor")],
+        factor: Annotated[pa.Int64Scalar, ConstParam("Multiplication factor")],
     ) -> Annotated[pa.Int64Array, Returns()]:
-        """Multiply values by the constant factor."""
+        """Multiply values by the constant factor.
+
+        ``factor`` is annotated as a ``pa.Int64Scalar`` (not a Python ``int``), so
+        the SDK delivers the typed Arrow scalar straight through and it can be
+        passed directly into ``pc.multiply``. Passing a bare Python int instead
+        makes pyarrow infer an Arrow scalar on every call — ~40-50x slower on
+        Windows than a typed scalar, and the dominant per-batch cost for a scalar
+        UDF. This is the idiomatic fast pattern for compute-bound constants.
+        """
         return pc.multiply(value, factor)
 
 

{vgi_python-0.8.8 → vgi_python-0.8.10}/vgi/arguments.py

@@ -109,6 +109,46 @@ COMPLEX_ARRAY_CLASSES: set[type] = {
 }
 
 
+# Simple scalar classes that can be inferred automatically. Annotating a const
+# parameter with one of these — ``Annotated[pa.Int64Scalar, ConstParam(...)]`` —
+# makes the SDK deliver the typed ``pa.Scalar`` straight through to ``compute()``
+# instead of converting it to a Python object via ``as_py()``. That lets the
+# const be passed directly into ``pyarrow.compute`` with no per-call scalar
+# re-inference, which is ~40-50x slower on Windows than a typed scalar. Built
+# defensively so a pyarrow release missing a class name doesn't break import.
+def _build_scalar_class_to_datatype() -> dict[type, pa.DataType]:
+    pairs: list[tuple[str, pa.DataType]] = [
+        ("Int8Scalar", pa.int8()),
+        ("Int16Scalar", pa.int16()),
+        ("Int32Scalar", pa.int32()),
+        ("Int64Scalar", pa.int64()),
+        ("UInt8Scalar", pa.uint8()),
+        ("UInt16Scalar", pa.uint16()),
+        ("UInt32Scalar", pa.uint32()),
+        ("UInt64Scalar", pa.uint64()),
+        ("HalfFloatScalar", pa.float16()),
+        ("FloatScalar", pa.float32()),
+        ("DoubleScalar", pa.float64()),
+        ("StringScalar", pa.string()),
+        ("LargeStringScalar", pa.large_string()),
+        ("BinaryScalar", pa.binary()),
+        ("LargeBinaryScalar", pa.large_binary()),
+        ("BooleanScalar", pa.bool_()),
+        ("Date32Scalar", pa.date32()),
+        ("Date64Scalar", pa.date64()),
+        ("NullScalar", pa.null()),
+    ]
+    out: dict[type, pa.DataType] = {}
+    for name, dt in pairs:
+        cls = getattr(pa, name, None)
+        if isinstance(cls, type):
+            out[cls] = dt
+    return out
+
+
+SCALAR_CLASS_TO_DATATYPE: dict[type, pa.DataType] = _build_scalar_class_to_datatype()
+
+
 # Sentinel for missing default value - proper type pattern
 class _MissingType:
     """Sentinel type for missing default values.
@@ -158,6 +198,7 @@ __all__ = [
     "Param",
     "PYTHON_TO_ARROW",
     "Returns",
+    "SCALAR_CLASS_TO_DATATYPE",
     "TableInput",
     "TaggedUnion",
     "TypeBoundPredicate",

{vgi_python-0.8.8 → vgi_python-0.8.10}/vgi/catalog/__init__.py

@@ -15,6 +15,7 @@ from vgi.catalog.catalog_interface import (
     CatalogInterface,
     CatalogObject,
     CatalogSchemaObject,
+    CopyFromFormatInfo,
     FunctionInfo,
     FunctionType,
     IndexConstraintType,
@@ -67,6 +68,7 @@ __all__ = [
     "TableInfo",
     "ViewInfo",
     "FunctionInfo",
+    "CopyFromFormatInfo",
     "ScanBranch",
     "ScanBranchesResult",
     "ScanFunctionResult",

{vgi_python-0.8.8 → vgi_python-0.8.10}/vgi/protocol.py

@@ -196,6 +196,10 @@ class BindRequest(ArrowSerializableDataclass):
             accessor), not at on_bind.
         at_value: Value of the time-travel ``AT`` clause for this scan; ``None`` when
             the scan has no AT clause. See ``at_unit`` for the inline-bind caveat.
+        copy_from: The ``COPY ... FROM`` context (source format + path); ``None``
+            unless this bind/init opens a COPY-FROM scan.
+        copy_to: The ``COPY ... TO`` context (destination format + path); ``None``
+            unless this bind/init opens a COPY-TO sink.
     """
 
     function_name: str

{vgi_python-0.8.8 → vgi_python-0.8.10}/vgi/scalar_function.py

@@ -48,6 +48,7 @@ from vgi.arguments import (
     _PYTHON_TO_ARROW,
     ARRAY_CLASS_TO_DATATYPE,
     COMPLEX_ARRAY_CLASSES,
+    SCALAR_CLASS_TO_DATATYPE,
     Arg,
     Arguments,
     ArgumentValidationError,
@@ -212,6 +213,25 @@ def _param_to_arg(param: Param, base_type: type, position: int) -> Arg[Any]:
     )
 
 
+def _is_scalar_annotation(base_type: object) -> bool:
+    """Whether a [`ConstParam`][] is annotated with a pyarrow scalar class.
+
+    ``Annotated[pa.Int64Scalar, ConstParam(...)]`` (or the generic ``pa.Scalar``)
+    signals that the typed Arrow scalar should be delivered to ``compute()``
+    unchanged, instead of converting it to a Python value via ``as_py()``. The
+    scalar can then flow straight into ``pyarrow.compute`` with no per-call scalar
+    re-inference (the latter is ~40-50x slower on Windows than a typed scalar).
+
+    Args:
+        base_type: The type from the ``Annotated`` first argument.
+
+    Returns:
+        True iff ``base_type`` is ``pa.Scalar`` or a subclass.
+
+    """
+    return isinstance(base_type, type) and issubclass(base_type, pa.Scalar)
+
+
 def _const_param_to_arg(const_param: ConstParam, base_type: type, position: int) -> Arg[Any]:
     """Convert [`ConstParam`][] dataclass to internal [`Arg`][] object.
 
@@ -235,6 +255,15 @@ def _const_param_to_arg(const_param: ConstParam, base_type: type, position: int)
     elif base_type in _PYTHON_TO_ARROW:
         # Infer from Annotated first argument
         arrow_type = _PYTHON_TO_ARROW[base_type]
+    elif base_type in SCALAR_CLASS_TO_DATATYPE:
+        # Annotated[pa.Int64Scalar, ConstParam(...)] — infer from the scalar class
+        # and deliver the typed scalar through (see _is_scalar_annotation).
+        arrow_type = SCALAR_CLASS_TO_DATATYPE[base_type]
+    elif _is_scalar_annotation(base_type):
+        raise TypeError(
+            f"Cannot infer Arrow type from {getattr(base_type, '__name__', base_type)}. "
+            f"Use a concrete scalar class (e.g. pa.Int64Scalar) or set arrow_type=... on ConstParam()."
+        )
     else:
         raise TypeError(
             f"Cannot infer Arrow type from {base_type}. "
@@ -791,6 +820,7 @@ class ScalarFunction(ScalarFunctionGenerator):
 
     _compute_params: dict[str, Arg[Any]]  # Regular Param() arguments (arrays)
     _const_params: dict[str, Arg[Any]]  # ConstParam() arguments (scalars)
+    _const_scalar_params: set[str]  # ConstParams annotated as pa.Scalar — delivered un-as_py()'d
     _setting_params: dict[str, str]  # Setting params: param_name -> setting_key
     _secret_params: dict[str, Secret]  # Secret params: param_name -> Secret instance
     _output_length_param: str | None  # OutputLength param name (batch row count)
@@ -866,6 +896,7 @@ class ScalarFunction(ScalarFunctionGenerator):
 
         compute_params: dict[str, Arg[Any]] = {}
         const_params: dict[str, Arg[Any]] = {}
+        const_scalar_params: set[str] = set()  # ConstParams annotated as pa.Scalar
         output_length_param: str | None = None  # param that receives batch row count
         auth_param: str | None = None  # param that receives AuthContext
         returns_output_type: pa.DataType | None = None
@@ -940,6 +971,8 @@ class ScalarFunction(ScalarFunctionGenerator):
                         # _resolution_index points to Arguments.positional index
                         arg._resolution_index = const_index
                         const_params[name] = arg
+                        if _is_scalar_annotation(base_type):
+                            const_scalar_params.add(name)
                         setattr(cls, name, _ConstArgDescriptor(arg, name))
                         overall_position += 1
                         const_index += 1
@@ -966,6 +999,7 @@ class ScalarFunction(ScalarFunctionGenerator):
 
         cls._compute_params = compute_params
         cls._const_params = const_params
+        cls._const_scalar_params = const_scalar_params
         cls._setting_params = setting_params
         cls._secret_params = secret_params
         cls._output_length_param = output_length_param
@@ -1051,14 +1085,22 @@ class ScalarFunction(ScalarFunctionGenerator):
                 # Regular param: extract column by index
                 kwargs[name] = batch.column(col_idx)
 
-        # Const params: extract scalar values from arguments
+        # Const params: extract values from the constant arguments. Params annotated
+        # with a pyarrow scalar class (e.g. Annotated[pa.Int64Scalar, ConstParam(...)])
+        # receive the typed pa.Scalar unchanged, so it can be passed straight into
+        # pyarrow.compute with no per-call scalar re-inference; all others get the
+        # Python value via as_py() (backward compatible).
         for name, arg in cls._const_params.items():
             # Use _resolution_index for Arguments.positional lookup
             arg_idx = cast(int, arg._resolution_index)
             # Get the scalar value from arguments
             scalar = bind_call.arguments.positional[arg_idx]
-            # Convert to Python value
-            kwargs[name] = scalar.as_py() if scalar is not None else None
+            if scalar is None:
+                kwargs[name] = None
+            elif name in cls._const_scalar_params:
+                kwargs[name] = scalar
+            else:
+                kwargs[name] = scalar.as_py()
 
         # Setting params: extract pa.Scalar from settings RecordBatch
         if bind_call.settings is not None and cls._setting_params:

{vgi_python-0.8.8 → vgi_python-0.8.10}/vgi/table_function.py

@@ -300,7 +300,7 @@ def _secret_scalar_str(v: Any) -> str:
     return "" if py is None else str(py)
 
 
-class ResolvedSecrets(dict):
+class ResolvedSecrets(dict[str, dict[str, Any]]):
     """Resolved secrets keyed by secret name, with type- and scope-aware lookup.
 
     A plain ``dict`` (so ``secrets[name]`` and ``secrets.get(name)`` still work)
@@ -514,7 +514,7 @@ class InitParams[TArgs]:
     output_schema: pa.Schema
 
     settings: dict[str, pa.Scalar[Any]]
-    secrets: dict[str, dict[str, pa.Scalar[Any]]]
+    secrets: ResolvedSecrets
 
     storage: BoundStorage
     auth_context: AuthContext = AuthContext.anonymous()
@@ -569,7 +569,7 @@ class ProcessParams[TArgs]:
     output_schema: pa.Schema
 
     settings: dict[str, pa.Scalar[Any]]
-    secrets: dict[str, dict[str, pa.Scalar[Any]]]
+    secrets: ResolvedSecrets
 
     storage: BoundStorage
     auth_context: AuthContext = AuthContext.anonymous()

{vgi_python-0.8.8 → vgi_python-0.8.10}/vgi/worker.py

@@ -146,6 +146,7 @@ from vgi.table_buffering_function import (
 )
 from vgi.table_function import (
     ProcessParams,
+    ResolvedSecrets,
     SecretsAccessor,
     TableCardinality,
     TableFunctionBase,
@@ -2407,7 +2408,7 @@ class Worker:
             init_response=None,
             output_schema=pa.schema([]),
             settings={},
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )
@@ -2513,7 +2514,7 @@ class Worker:
             init_response=None,
             output_schema=pa.schema([]),
             settings={},
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )
@@ -2576,7 +2577,7 @@ class Worker:
             init_response=None,
             output_schema=request.output_schema,
             settings={},
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )
@@ -2815,7 +2816,7 @@ class Worker:
             init_response=None,
             output_schema=request.output_schema,
             settings={},
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )
@@ -2912,7 +2913,7 @@ class Worker:
             init_response=None,
             output_schema=output_schema,
             settings={},
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )
@@ -3027,7 +3028,7 @@ class Worker:
             init_response=None,
             output_schema=output_schema,
             settings={},
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )
@@ -3121,7 +3122,7 @@ class Worker:
             init_response=None,
             output_schema=request.output_schema,
             settings=_batch_to_scalar_dict(request.settings),
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )
@@ -3187,7 +3188,7 @@ class Worker:
             init_response=None,
             output_schema=session.output_schema,
             settings={},
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )
@@ -3280,7 +3281,7 @@ class Worker:
             init_response=None,
             output_schema=session.output_schema,
             settings={},
-            secrets={},
+            secrets=ResolvedSecrets(),
             storage=storage,
             auth_context=ctx.auth,
         )

vgi_python-0.8.8/tests/test_docstrings.py

@@ -1,60 +0,0 @@
-# Copyright 2025, 2026 Query Farm LLC - https://query.farm
-
-"""Docstring-consistency gate.
-
-Runs pydoclint over the ``vgi/`` package as part of the test suite, mirroring
-the CI ``Docstring lint (pydoclint)`` step. pydoclint complements ruff's ``D``
-rules: ruff checks docstring *shape*, while pydoclint verifies that documented
-arguments, return values, yields, and dataclass attributes actually match the
-code. Configuration lives in ``[tool.pydoclint]`` in ``pyproject.toml`` — this
-test invokes the same CLI, so there is no duplicated rule set.
-"""
-
-import re
-import shutil
-import subprocess
-from pathlib import Path
-
-import pytest
-
-_REPO_ROOT = Path(__file__).resolve().parents[1]
-
-# A real violation line looks like ``    42: DOC101: ...``. If pydoclint exits
-# non-zero without emitting any such code, it failed to *run* (e.g. import
-# error) rather than finding violations — see the environment note below.
-_VIOLATION_RE = re.compile(r"\bDOC\d{3}\b")
-
-
-def test_pydoclint_clean() -> None:
-    """``vgi/`` must pass the pydoclint docstring gate (config in pyproject.toml)."""
-    pydoclint = shutil.which("pydoclint")
-    if pydoclint is None:  # pragma: no cover - dev dependency should always be present
-        pytest.skip("pydoclint is not installed")
-
-    result = subprocess.run(
-        [pydoclint, "vgi/"],
-        cwd=_REPO_ROOT,
-        capture_output=True,
-        text=True,
-    )
-    output = result.stdout + result.stderr
-
-    if result.returncode == 0:
-        return
-
-    # pydoclint depends on ``docstring-parser-fork`` while ``vgi-rpc`` depends on
-    # the upstream ``docstring-parser``; both claim the ``docstring_parser``
-    # import namespace, so on some interpreter/OS combinations the wrong files
-    # win and pydoclint crashes on import. That's a broken tool environment, not
-    # a docstring problem — skip rather than fail (the gate still runs on every
-    # other matrix cell where the tool is healthy).
-    if not _VIOLATION_RE.search(output):  # pragma: no cover - env-dependent
-        pytest.skip(f"pydoclint could not run in this environment:\n{output}")
-
-    pytest.fail(
-        "pydoclint found docstring violations:\n\n"
-        f"{output}\n"
-        "Fix the docstrings, or run "
-        "`uv run pydoclint --generate-baseline=True --baseline=.pydoclint-baseline vgi/` "
-        "to defer them (see [tool.pydoclint] in pyproject.toml)."
-    )