vgplot 0.30.0__tar.gz → 0.32.0b0__tar.gz

{vgplot-0.30.0 → vgplot-0.32.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: vgplot
-Version: 0.30.0
+Version: 0.32.0-beta.0
 Summary: A Python API for authoring Mosaic vgplot visualizations
 Project-URL: homepage, https://github.com/uwdata/mosaic
 Requires-Python: >=3.10

{vgplot-0.30.0 → vgplot-0.32.0b0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vgplot-python",
-  "version": "0.30.0",
+  "version": "0.32.0-beta.0",
   "private": true,
   "scripts": {
     "prerelease": "uv run ruff check && uv run ruff format --check",

{vgplot-0.30.0 → vgplot-0.32.0b0}/tests/test_full_round_trip.py

@@ -4,6 +4,8 @@
 # in sync (same filenames).
 #
 # Run: pytest packages/vgplot/vgplot-python/tests/test_full_round_trip.py
+from __future__ import annotations
+
 import json
 from pathlib import Path
 from typing import Any
@@ -16,27 +18,29 @@ ESM_DIR = SPEC_DIR / "esm"
 PYTHON_DIR = SPEC_DIR / "python"
 
 
-def load_json_fixture(name: str) -> dict:
+def load_json_fixture(name: str) -> dict[str, Any]:
     return json.loads((JSON_DIR / f"{name}.json").read_text(encoding="utf-8"))
 
 
-def run_spec_file_with_exec(path: Path) -> dict:
-    namespace: dict[str, Any] = {
+def run_spec_file_with_exec(path: Path) -> dict[str, Any]:
+    namespace = {
         "__name__": "__spec_exec__",
         "__file__": str(path),
         "__builtins__": __builtins__,
     }
     code = compile(path.read_text(encoding="utf-8"), str(path), "exec")
-    exec(code, namespace)
+    exec(code, namespace)  # ruff: ignore[exec-builtin]
 
     view = namespace.get("view")
     if view is None:
-        raise AssertionError(f"`{path.name}` must define a top-level `view` variable")
+        msg = f"`{path.name}` must define a top-level `view` variable"
+        raise AssertionError(msg)
     if not hasattr(view, "to_dict"):
-        raise AssertionError(f"`view` in `{path.name}` does not expose to_dict()")
+        msg = f"`view` in `{path.name}` does not expose to_dict()"
+        raise AssertionError(msg)
     # Execute to_dict() within the spec namespace so frame inspection finds the right variables
     namespace["__view__"] = view
-    exec("__result__ = __view__.to_dict()", namespace)
+    exec("__result__ = __view__.to_dict()", namespace)  # ruff: ignore[exec-builtin]
     return namespace["__result__"]
 
 
@@ -45,13 +49,13 @@ ESM_EXAMPLES = sorted(path.stem for path in ESM_DIR.glob("*.js"))
 PYTHON_EXAMPLES = sorted(path.stem for path in PYTHON_DIR.glob("*.py"))
 
 
-def test_generated_examples_stay_in_sync():
+def test_generated_examples_stay_in_sync() -> None:
     assert PYTHON_EXAMPLES == JSON_EXAMPLES
     assert ESM_EXAMPLES == JSON_EXAMPLES
 
 
 @pytest.mark.parametrize("example_name", PYTHON_EXAMPLES)
-def test_python_round_trip(example_name: str):
+def test_python_round_trip(example_name: str) -> None:
     generated = run_spec_file_with_exec(PYTHON_DIR / f"{example_name}.py")
     original = load_json_fixture(example_name)
 

{vgplot-0.30.0 → vgplot-0.32.0b0}/tests/test_python_api.py

@@ -1,9 +1,10 @@
 # Unit tests for the vgplot Python API, covering behaviors that the
 # generated-spec round-trip suite does not exercise directly.
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 import pytest
-
 import vgplot as vg
 from vgplot.plot import Mark
 
@@ -12,7 +13,7 @@ class TestGeneratedMarks:
     """Marks are generated from the schema; there is no dynamic fallback, so
     unknown names fail loudly rather than being silently fabricated."""
 
-    def test_positional_data_with_encodings_is_kept(self):
+    def test_positional_data_with_encodings_is_kept(self) -> None:
         # A leading positional arg is the data source even when the call also
         # has keyword encodings.
         mark = vg.waffle_y("athletes", x="a", y={"count": ""})
@@ -22,45 +23,45 @@ class TestGeneratedMarks:
         assert d["data"] == {"from": "athletes"}
         assert d["x"] == "a"
 
-    def test_explicit_none_channel_is_preserved(self):
+    def test_explicit_none_channel_is_preserved(self) -> None:
         # Passing a channel explicitly as None keeps it in the output (distinct
         # from not passing it at all).
         assert vg.line_y("t", x="a", z=None).to_dict()["z"] is None
         assert "z" not in vg.line_y("t", x="a").to_dict()
 
-    def test_unknown_name_raises(self):
+    def test_unknown_name_raises(self) -> None:
         # No __getattr__ fallback: a missing or mis-typed API name is an error.
         with pytest.raises(AttributeError):
-            vg.some_custom_mark  # pyright: ignore[reportAttributeAccessIssue] # ty: ignore[unresolved-attribute]
+            _ = vg.some_custom_mark  # pyright: ignore[reportAttributeAccessIssue] # ty: ignore[unresolved-attribute]
         with pytest.raises(AttributeError):
-            vg.definitely_not_a_real_directive  # pyright: ignore[reportAttributeAccessIssue] # ty: ignore[unresolved-attribute]
+            _ = vg.definitely_not_a_real_directive  # pyright: ignore[reportAttributeAccessIssue] # ty: ignore[unresolved-attribute]
 
 
 class TestDataHelpers:
-    def test_json_inline_data(self):
+    def test_json_inline_data(self) -> None:
         d = vg.json([{"a": 1}, {"a": 2}])
         assert d.to_dict() == {"type": "json", "data": [{"a": 1}, {"a": 2}]}
 
-    def test_json_file(self):
+    def test_json_file(self) -> None:
         assert vg.json(file="x.json").to_dict() == {"type": "json", "file": "x.json"}
 
 
 class TestParams:
-    def test_date_param(self):
+    def test_date_param(self) -> None:
         from datetime import date
 
         assert vg.param(date(2013, 5, 13)).param_def() == {"date": "2013-05-13"}
 
-    def test_datetime_param(self):
+    def test_datetime_param(self) -> None:
         from datetime import datetime
 
-        assert vg.param(datetime(2013, 5, 13, 10, 30)).param_def() == {
+        assert vg.param(datetime(2013, 5, 13, 10, 30)).param_def() == {  # ruff: ignore[call-datetime-without-tzinfo]
             "date": "2013-05-13T10:30:00"
         }
 
 
 class TestAutoNaming:
-    def test_auto_param_name_skips_explicit_name(self):
+    def test_auto_param_name_skips_explicit_name(self) -> None:
         from vgplot.spec import Spec
 
         named = vg.param(1)
@@ -79,7 +80,7 @@ class TestDataFrames:
     referenced as a table, and carried in the spec's data section for the host
     (e.g. the widget) to register."""
 
-    def test_frame_is_referenced_and_named_after_variable(self):
+    def test_frame_is_referenced_and_named_after_variable(self) -> None:
         pytest.importorskip("pyarrow")
         import pyarrow as pa
 
@@ -90,7 +91,7 @@ class TestDataFrames:
         assert d["plot"][0]["data"] == {"from": "weather"}
         assert d["data"]["weather"] is weather
 
-    def test_frame_and_datadef_share_the_data_section(self):
+    def test_frame_and_datadef_share_the_data_section(self) -> None:
         pytest.importorskip("pyarrow")
         import pyarrow as pa
 
@@ -109,11 +110,11 @@ if TYPE_CHECKING:
 
     def typing_dunder_all() -> None:
         # Ok
-        vg.arrow
-        vg.errorbar_x
-        vg.mark
+        _ = vg.arrow
+        _ = vg.errorbar_x
+        _ = vg.mark
 
         # TODO @dangotbanned: Get pyright to error on these
         # Error (`_generated` modules)
-        vg.attributes  # ty: ignore[unresolved-attribute]
-        vg.marks  # ty: ignore[unresolved-attribute]
+        _ = vg.attributes  # ty: ignore[unresolved-attribute]
+        _ = vg.marks  # ty: ignore[unresolved-attribute]

vgplot-0.32.0b0/tests/test_schema_coverage.py

@@ -0,0 +1,65 @@
+# Ensures the exported vgplot API covers every mark, attribute, interactor, and
+# input in the Mosaic JSON schema (the source of truth). Marks and attributes
+# are generated; interactors and inputs are hand-written. This guards against a
+# schema addition that was never generated or hand-added.
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import vgplot as vg
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from typing_extensions import TypedDict
+
+    class Schema(TypedDict, closed=True, total=False):
+        properties: dict[str, dict[str, Any]]
+        anyOf: Sequence[Schema]
+
+    class Definitions(TypedDict, extra_items=Schema):
+        PlotAttributes: Schema
+
+
+ROOT = Path(__file__).resolve().parents[4]
+SCHEMA = ROOT / "docs" / "public" / "schema" / "latest.json"
+
+# Schema names whose Python export is renamed or intentionally absent.
+RENAME = {"table": "table_input"}  # `table` input -> vg.table_input (vg.table is data)
+IGNORE = {"value"}  # internal selection const, not a user-facing interactor
+
+
+def _snake(name: str) -> str:
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name).lower()
+
+
+def get_discriminator_values(defs: Definitions, key: str) -> set[str]:
+    out: set[str] = set()
+    for d in defs.values():
+        if (p := d.get("properties")) and (c := p.get(key, {}).get("const")):
+            out.add(c)
+        elif u := d.get("anyOf"):
+            out.update(
+                c
+                for member in u
+                if (p := member.get("properties"))
+                and (c := p.get(key, {}).get("const"))
+            )
+    return out
+
+
+def test_schema_surface_is_exported() -> None:
+    defs: Definitions = json.loads(SCHEMA.read_text("utf-8"))["definitions"]
+    names = (
+        get_discriminator_values(defs, "mark")
+        | get_discriminator_values(defs, "select")
+        | get_discriminator_values(defs, "input")
+        | set(defs["PlotAttributes"].get("properties", ()))
+    ) - IGNORE
+
+    exported = set(vg.__all__)
+    missing = sorted(n for n in names if RENAME.get(n, _snake(n)) not in exported)
+    assert not missing, f"schema names with no exported vgplot function: {missing}"

{vgplot-0.30.0 → vgplot-0.32.0b0}/tests/test_unset_sentinel.py

@@ -32,7 +32,7 @@ def test_unset_pickle() -> None:
     import pickle
 
     unset = _import_unset()
-    assert pickle.loads(pickle.dumps(unset)) is unset  # noqa: S301
+    assert pickle.loads(pickle.dumps(unset)) is unset
 
 
 def test_unset_type_expression_union() -> None:
@@ -62,7 +62,7 @@ if TYPE_CHECKING:
     from typing_extensions import assert_type
 
     def typing_unset(
-        a: UNSET, b: str | UNSET, c: Any | UNSET, d: int | None | UNSET = UNSET
+        a: UNSET, b: str | UNSET, c: Any | UNSET, d: int | UNSET | None = UNSET
     ) -> None:
         assert_type(a, UNSET)
         assert_type(b, str | UNSET)

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/__init__.py

@@ -1,50 +1,54 @@
-from .spec import spec, Spec, View
-from .data import parquet, csv, spatial, table, json, data
+from __future__ import annotations
+
+from ._generated import *  # noqa: F403
+from ._generated import __all__ as _generated_all
+from .data import csv, data, json, parquet, spatial, table
+from .encodings import channels, sql
 from .params import param, selection
-from .encodings import sql, channels
 from .plot import (
-    plot,
-    source,
-    mark,
+    brush,
+    checkbox,
+    color_legend,
     directive,
-    margins,
-    vconcat,
     hconcat,
-    vspace,
+    highlight,
     hspace,
-    slider,
-    select,
-    checkbox,
-    menu,
-    search,
-    table_input,
     input,
-    option,
-    brush,
-    sort,
     interval_x,
-    interval_y,
     interval_xy,
-    toggle,
-    toggle_x,
-    toggle_y,
-    toggle_color,
+    interval_y,
+    margins,
+    mark,
+    menu,
+    nearest,
     nearest_x,
     nearest_y,
-    region,
-    highlight,
+    opacity_legend,
+    option,
     pan,
     pan_x,
     pan_y,
     pan_zoom,
     pan_zoom_x,
     pan_zoom_y,
-    color_legend,
-    opacity_legend,
+    plot,
+    region,
+    search,
+    select,
+    slider,
+    sort,
+    source,
     symbol_legend,
+    table_input,
+    toggle,
+    toggle_color,
+    toggle_x,
+    toggle_y,
+    toggle_z,
+    vconcat,
+    vspace,
 )
-from ._generated import *  # noqa: F401, F403
-from ._generated import __all__ as _generated_all
+from .spec import Spec, View, spec
 
 __all__ = [
     "Spec",
@@ -67,6 +71,7 @@ __all__ = [
     "margins",
     "mark",
     "menu",
+    "nearest",
     "nearest_x",
     "nearest_y",
     "opacity_legend",
@@ -97,6 +102,7 @@ __all__ = [
     "toggle_color",
     "toggle_x",
     "toggle_y",
+    "toggle_z",
     "vconcat",
     "vspace",
 ] + list(_generated_all)  # pyright: ignore[reportUnsupportedDunderAll]

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/_compat.py

@@ -19,8 +19,6 @@ from __future__ import annotations
 
 import sys
 import typing
-
-# ruff: noqa: A002
 from contextlib import suppress
 from importlib.util import find_spec
 from typing import TYPE_CHECKING, Any, ClassVar
@@ -92,8 +90,8 @@ def _sentinel_backport_pre_py_3_15() -> Any:
 
 if TYPE_CHECKING:
     # Was renamed in https://github.com/python/typing_extensions/releases/tag/4.16.0
-    from typing_extensions import Sentinel as sentinel  # noqa: N813
-else:  # noqa: PLR5501
+    from typing_extensions import Sentinel as sentinel
+else:  # ruff: ignore[collapsible-else-if]
     if sys.version_info >= (3, 15):
         from builtins import sentinel
     else:

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/_generated/__init__.py

@@ -1,10 +1,12 @@
 # DO NOT EDIT. Generated from the Mosaic JSON schema by bin/generate-python-api.js.
 # Regenerate with: pnpm run generate:python-api
+from __future__ import annotations
+
 from .attributes import *  # noqa: F403
-from .encodings import *  # noqa: F403
-from .marks import *  # noqa: F403
 from .attributes import __all__ as _attr_all
+from .encodings import *  # noqa: F403
 from .encodings import __all__ as _enc_all
+from .marks import *  # noqa: F403
 from .marks import __all__ as _mark_all
 
-__all__ = [*_mark_all, *_attr_all, *_enc_all]  # pyright: ignore[reportUnsupportedDunderAll]
+__all__ = [*_mark_all, *_attr_all, *_enc_all]  # pyright: ignore[reportUnsupportedDunderAll]  # ruff: ignore[invalid-all-object]

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/_generated/attributes.py

@@ -1,9 +1,15 @@
 # DO NOT EDIT. Generated from the Mosaic JSON schema by bin/generate-python-api.js.
 # Regenerate with: pnpm run generate:python-api
 
-from .._types import AttrValue
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from ..plot import Directive
 
+if TYPE_CHECKING:
+    from .._types import AttrValue
+
 
 def align(value: AttrValue) -> Directive:
     """How to distribute unused space in the **range** for *point* and *band* scales."""
@@ -1130,9 +1136,9 @@ __all__ = [
     "fx_tick_format",
     "fx_tick_padding",
     "fx_tick_rotate",
-    "fx_ticks",
     "fx_tick_size",
     "fx_tick_spacing",
+    "fx_ticks",
     "fy_align",
     "fy_aria_description",
     "fy_aria_label",
@@ -1156,9 +1162,9 @@ __all__ = [
     "fy_tick_format",
     "fy_tick_padding",
     "fy_tick_rotate",
-    "fy_ticks",
     "fy_tick_size",
     "fy_tick_spacing",
+    "fy_ticks",
     "grid",
     "height",
     "inset",
@@ -1250,11 +1256,11 @@ __all__ = [
     "x_tick_format",
     "x_tick_padding",
     "x_tick_rotate",
-    "x_ticks",
     "x_tick_size",
     "x_tick_spacing",
-    "xy_domain",
+    "x_ticks",
     "x_zero",
+    "xy_domain",
     "y_align",
     "y_aria_description",
     "y_aria_label",
@@ -1286,8 +1292,8 @@ __all__ = [
     "y_tick_format",
     "y_tick_padding",
     "y_tick_rotate",
-    "y_ticks",
     "y_tick_size",
     "y_tick_spacing",
+    "y_ticks",
     "y_zero",
 ]

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/_generated/encodings.py

@@ -1,6 +1,8 @@
 # DO NOT EDIT. Generated from the Mosaic JSON schema by bin/generate-python-api.js.
 # Regenerate with: pnpm run generate:python-api
 
+from __future__ import annotations
+
 from typing import Any
 
 from .._types import UNSET, TransformArg
@@ -150,7 +152,7 @@ def mode(col: TransformArg, **options: Any) -> dict[str, Any]:
 
 
 def nth_value(
-    col: TransformArg, offset: TransformArg | UNSET = UNSET, **options: Any
+    col: TransformArg, offset: TransformArg, **options: Any
 ) -> dict[str, Any]:
     """Get the nth value of the given column in the current window frame, counting from one."""
     return _transform("nth_value", (col, offset), options)
@@ -247,6 +249,6 @@ __all__ = [
     "stddev",
     "stddev_pop",
     "sum",
-    "variance",
     "var_pop",
+    "variance",
 ]

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/_generated/marks.py

@@ -1,6 +1,8 @@
 # DO NOT EDIT. Generated from the Mosaic JSON schema by bin/generate-python-api.js.
 # Regenerate with: pnpm run generate:python-api
 
+from __future__ import annotations
+
 from typing import Any
 
 from .._types import UNSET, ChannelValue, MarkData

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/_types.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from collections.abc import Sequence
 from datetime import date
-from typing import Any
+from typing import Any, TypeAlias
 
 from vgplot._compat import sentinel
 
@@ -18,7 +20,9 @@ AttrValue = (
     str | float | bool | date | dict[str, Any] | Sequence[Any] | _ParamBase | None
 )
 MarkData = str | FromRef | DataDef | dict[str, Any] | Sequence[Any] | _ParamBase | None
-TransformArg = str | float | bool | _ParamBase
+TransformArg = str | float | bool | dict[str, Any] | _ParamBase
 
 UNSET = sentinel("UNSET")
 """Sentinel for mark channels that were not passed (distinct from None)."""
+
+MimeBundle: TypeAlias = dict[str, str] | tuple[dict[str, Any], dict[str, Any]] | None

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/params.py

@@ -39,10 +39,10 @@ class ParamValue(_ParamBase):
 
 
 class ParamArray(_ParamBase):
-    def __init__(self, values: list) -> None:
-        self._values = list(values)
+    def __init__(self, values: list[Any]) -> None:
+        self._values: list[Any] = list(values)
 
-    def param_def(self, *, param_names: dict[int, str] | None = None) -> Any:
+    def param_def(self, *, param_names: dict[int, str] | None = None) -> list[Any]:
         return [_resolve(v, param_names) for v in self._values]
 
     def __repr__(self) -> str:
@@ -54,8 +54,8 @@ class SelectionDef(_ParamBase):
         self._select = select
         self._opts = {k: v for k, v in opts.items() if v is not None}
 
-    def param_def(self, *, param_names: dict[int, str] | None = None) -> Any:
-        d: dict = {"select": self._select}
+    def param_def(self, *, param_names: dict[int, str] | None = None) -> dict[str, Any]:
+        d: dict[str, Any] = {"select": self._select}
         d.update(_resolve(self._opts, param_names))
         return d
 
@@ -70,7 +70,7 @@ def param(value: Any = None) -> _ParamBase:
     return ParamValue(value)
 
 
-class selection:
+class selection:  # ruff: ignore[invalid-class-name]
     """Namespace for creating selection params."""
 
     @staticmethod

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/plot.py

@@ -2,15 +2,18 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from .util import camelize, omit_none
-from .params import _ParamBase
 from .data import DataDef, is_frame
+from .params import _ParamBase
+from .util import camelize, omit_none
+
+if TYPE_CHECKING:
+    from vgplot.spec import View
 
 
 class FromRef:
-    def __init__(self, name: str, **opts: Any):
+    def __init__(self, name: str, **opts: Any) -> None:
         self.name = name
         self.opts = {camelize(k): v for k, v in opts.items() if v is not None}
 
@@ -27,7 +30,7 @@ class Directive:
     key: str
     value: Any
 
-    def to_kv(self):
+    def to_kv(self) -> tuple[str, Any]:
         return camelize(self.key), self.value
 
 
@@ -95,7 +98,7 @@ def plot(
     *items: Mark | Directive | Mapping[str, Any],
     param_names: dict[int, str] | None = None,
     **kwargs: Any,
-) -> Any:
+) -> View:
     from .spec import View
 
     marks: list[dict[str, Any]] = []
@@ -109,7 +112,8 @@ def plot(
         elif isinstance(item, (dict, Mapping)):
             marks.append({k: encode_value(v, param_names) for k, v in item.items()})
         else:
-            raise TypeError(f"Unsupported plot item: {item}")
+            msg = f"Unsupported plot item: {item}"
+            raise TypeError(msg)
     root: dict[str, Any] = {"plot": marks}
     root.update(directives)
     return View(root, **kwargs)
@@ -172,7 +176,7 @@ def _encode_component(
 # Layout helpers
 def vconcat(
     *items: Any, param_names: dict[int, str] | None = None, **kwargs: Any
-) -> Any:
+) -> View:
     from .spec import View
 
     return View(
@@ -182,7 +186,7 @@ def vconcat(
 
 def hconcat(
     *items: Any, param_names: dict[int, str] | None = None, **kwargs: Any
-) -> Any:
+) -> View:
     from .spec import View
 
     return View(
@@ -190,13 +194,13 @@ def hconcat(
     )
 
 
-def hspace(value: int | str) -> Any:
+def hspace(value: int | str) -> View:
     from .spec import View
 
     return View({"hspace": value})
 
 
-def vspace(value: int | str) -> Any:
+def vspace(value: int | str) -> View:
     from .spec import View
 
     return View({"vspace": value})
@@ -297,6 +301,16 @@ def toggle_color(bind: Any = None, peers: Any = None) -> dict[str, Any]:
     return _interactor("toggleColor", **{"as": bind, "peers": peers})
 
 
+def toggle_z(bind: Any = None, peers: Any = None) -> dict[str, Any]:
+    return _interactor("toggleZ", **{"as": bind, "peers": peers})
+
+
+def nearest(
+    bind: Any = None, field: Any = None, channels: Any = None
+) -> dict[str, Any]:
+    return _interactor("nearest", **{"as": bind, "field": field, "channels": channels})
+
+
 def nearest_x(
     bind: Any = None, field: Any = None, channels: Any = None
 ) -> dict[str, Any]:
@@ -417,7 +431,7 @@ def symbol_legend(
 _INPUT_ALIASES = {"bind": "as", "source": "from"}
 
 
-def input(kind: str, **opts: Any) -> Any:
+def input(kind: str, **opts: Any) -> View:
     from .spec import View
 
     payload: dict[str, Any] = {"input": kind}
@@ -443,7 +457,7 @@ def slider(
     step: Any = None,
     value: Any = None,
     **opts: Any,
-) -> Any:
+) -> View:
     return input(
         "slider",
         label=label,
@@ -463,7 +477,7 @@ def select(
     multiple: bool = False,
     value: Any = None,
     **opts: Any,
-) -> Any:
+) -> View:
     return input(
         "select",
         label=label,
@@ -475,7 +489,7 @@ def select(
     )
 
 
-def checkbox(label: str, bind: Any, value: bool = False, **opts: Any) -> Any:
+def checkbox(label: str, bind: Any, value: bool = False, **opts: Any) -> View:
     return input("checkbox", label=label, bind=bind, value=value, **opts)
 
 
@@ -488,7 +502,7 @@ def menu(
     column: Any = None,
     filter_by: Any = None,
     **opts: Any,
-) -> Any:
+) -> View:
     return input(
         "menu",
         label=label,
@@ -510,7 +524,7 @@ def search(
     filter_by: Any = None,
     type: Any = None,
     **opts: Any,
-) -> Any:
+) -> View:
     return input(
         "search",
         label=label,
@@ -534,7 +548,7 @@ def table_input(
     row_batch: Any = None,
     align: Any = None,
     **opts: Any,
-) -> Any:
+) -> View:
     return input(
         "table",
         source=source,

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/spec.py

@@ -2,12 +2,18 @@ from __future__ import annotations
 
 import inspect
 import json
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from .util import omit_none
-from .params import _ParamBase
 from .data import DataDef, is_frame
+from .params import _ParamBase
 from .plot import _encode_component
+from .util import omit_none
+
+if TYPE_CHECKING:
+    from duckdb import DuckDBPyConnection
+    from narwhals.typing import IntoFrame
+
+    from vgplot._types import MimeBundle
 
 
 def _caller_locals() -> dict[str, Any]:
@@ -80,10 +86,10 @@ class Spec:
         data: dict[str, Any] | None = None,
         data_names: dict[int, str] | None = None,
         params: dict[str, Any] | None = None,
-        plotDefaults: dict[str, Any] | None = None,
+        plotDefaults: dict[str, Any] | None = None,  # ruff: ignore[invalid-argument-name]
         plot_defaults: dict[str, Any] | None = None,
         config: dict[str, Any] | None = None,
-        view: dict[str, Any] | None = None,
+        view: dict[str, Any] | View | None = None,
         **extra: Any,
     ) -> None:
         # Serialize any DataDef values in data and build id->name mapping
@@ -170,7 +176,7 @@ class Spec:
     def to_json(self, **kwargs: Any) -> str:
         return json.dumps(self.to_dict(), **kwargs)
 
-    def _repr_mimebundle_(self, **kwargs):
+    def _repr_mimebundle_(self, **kwargs: Any) -> MimeBundle:
         try:
             from mosaic_widget import MosaicWidget
         except ImportError:
@@ -178,12 +184,17 @@ class Spec:
         widget = MosaicWidget(self.to_dict())
         return widget._repr_mimebundle_(**kwargs)
 
-    def show(self, con=None, data=None):
+    def show(
+        self,
+        con: DuckDBPyConnection | None = None,
+        data: dict[str, IntoFrame] | None = None,
+    ) -> None:
         try:
-            from mosaic_widget import MosaicWidget
             from IPython.display import display
+            from mosaic_widget import MosaicWidget
         except ImportError as e:
-            raise ImportError("pip install mosaic-widget") from e
+            msg = "pip install mosaic-widget"
+            raise ImportError(msg) from e
         widget = MosaicWidget(self.to_dict(), con=con, data=data)
         display(widget)
 
@@ -200,7 +211,7 @@ class View:
         view: dict[str, Any],
         *,
         data: dict[str, Any] | None = None,
-        plotDefaults: dict[str, Any] | None = None,
+        plotDefaults: dict[str, Any] | None = None,  # ruff: ignore[invalid-argument-name]
         plot_defaults: dict[str, Any] | None = None,
         config: dict[str, Any] | None = None,
         **extra: Any,
@@ -249,7 +260,7 @@ class View:
     def show(self, con: Any = None, data: Any = None) -> None:
         self._build_spec(_caller_locals()).show(con=con, data=data)
 
-    def _repr_mimebundle_(self, **kwargs: Any):
+    def _repr_mimebundle_(self, **kwargs: Any) -> MimeBundle:
         # Walk up frames to find the one where this View object lives
         frame = inspect.currentframe()
         frame = frame.f_back if frame is not None else None
@@ -268,10 +279,10 @@ def spec(
     *args: Any,
     data: dict[str, Any] | None = None,
     params: dict[str, Any] | None = None,
-    plotDefaults: dict[str, Any] | None = None,
+    plotDefaults: dict[str, Any] | None = None,  # ruff: ignore[invalid-argument-name]
     plot_defaults: dict[str, Any] | None = None,
     config: dict[str, Any] | None = None,
-    view: dict[str, Any] | None = None,
+    view: dict[str, Any] | View | None = None,
     **extra: Any,
 ) -> Spec:
     """Assemble a Spec from a view plus data sources and params.

{vgplot-0.30.0 → vgplot-0.32.0b0}/vgplot/util.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Any
 
 

vgplot-0.30.0/tests/test_schema_coverage.py

@@ -1,56 +0,0 @@
-# Ensures the exported vgplot API covers every mark, attribute, interactor, and
-# input in the Mosaic JSON schema (the source of truth). Marks and attributes
-# are generated; interactors and inputs are hand-written. This guards against a
-# schema addition that was never generated or hand-added.
-import json
-import re
-from pathlib import Path
-
-import vgplot as vg
-
-ROOT = Path(__file__).resolve().parents[4]
-SCHEMA = ROOT / "docs" / "public" / "schema" / "latest.json"
-
-# Schema names whose Python export is renamed or intentionally absent.
-RENAME = {"table": "table_input"}  # `table` input -> vg.table_input (vg.table is data)
-IGNORE = {"value"}  # internal selection const, not a user-facing interactor
-
-
-def _snake(name: str) -> str:
-    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name).lower()
-
-
-def _const(node: dict, key: str):
-    prop = node.get("properties", {}).get(key)
-    return prop["const"] if isinstance(prop, dict) and "const" in prop else None
-
-
-def _consts(defs: dict, key: str) -> set[str]:
-    """Const values for `key`, including intersection defs (anyOf/allOf) whose
-    branches all agree on a single const (e.g. the densityX mark)."""
-    out = set()
-    for d in defs.values():
-        c = _const(d, key)
-        if c is not None:
-            out.add(c)
-            continue
-        branch_consts = {
-            _const(b, key) for b in (d.get("anyOf") or d.get("allOf") or [])
-        } - {None}
-        if len(branch_consts) == 1:
-            out |= branch_consts
-    return out
-
-
-def test_schema_surface_is_exported():
-    defs = json.loads(SCHEMA.read_text("utf-8"))["definitions"]
-    names = (
-        _consts(defs, "mark")
-        | _consts(defs, "select")
-        | _consts(defs, "input")
-        | set(defs["PlotAttributes"]["properties"])
-    ) - IGNORE
-
-    exported = set(vg.__all__)
-    missing = sorted(n for n in names if RENAME.get(n, _snake(n)) not in exported)
-    assert not missing, f"schema names with no exported vgplot function: {missing}"