vgplot 0.29.1__tar.gz → 0.31.0__tar.gz

{vgplot-0.29.1 → vgplot-0.31.0}/.gitignore

@@ -22,6 +22,7 @@ transitionFolder
 # Virtual environment
 venv/
 .env/
+**/.python-version
 
 # Conda environment
 conda-env/

{vgplot-0.29.1 → vgplot-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: vgplot
-Version: 0.29.1
+Version: 0.31.0
 Summary: A Python API for authoring Mosaic vgplot visualizations
 Project-URL: homepage, https://github.com/uwdata/mosaic
 Requires-Python: >=3.10
@@ -59,18 +59,30 @@ brush = vg.selection.crossfilter()
 
 view = vg.vconcat(
     vg.plot(
-        vg.rect_y(flights, x=vg.bin("delay"), y=vg.count(),
-                  filter_by=brush, fill="steelblue",
-                  inset_left=0.5, inset_right=0.5),
+        vg.rect_y(
+            flights,
+            x=vg.bin("delay"),
+            y=vg.count(),
+            filter_by=brush,
+            fill="steelblue",
+            inset_left=0.5,
+            inset_right=0.5,
+        ),
         vg.interval_x(bind=brush),
         vg.x_domain("Fixed"),
         vg.x_label("Arrival Delay (min)"),
         vg.height(200),
     ),
     vg.plot(
-        vg.rect_y(flights, x=vg.bin("time"), y=vg.count(),
-                  filter_by=brush, fill="steelblue",
-                  inset_left=0.5, inset_right=0.5),
+        vg.rect_y(
+            flights,
+            x=vg.bin("time"),
+            y=vg.count(),
+            filter_by=brush,
+            fill="steelblue",
+            inset_left=0.5,
+            inset_right=0.5,
+        ),
         vg.interval_x(bind=brush),
         vg.x_domain("Fixed"),
         vg.x_label("Departure Time (hour)"),
@@ -94,9 +106,7 @@ bias = vg.param(0)
 view = vg.vconcat(
     vg.slider(label="Bias", bind=bias, min=0, max=1000, step=1),
     vg.plot(
-        vg.area_y(walk, x="t", y=vg.sql("v + $bias")),
-        vg.width(680),
-        vg.height(200),
+        vg.area_y(walk, x="t", y=vg.sql("v + $bias")), vg.width(680), vg.height(200)
     ),
 )
 

{vgplot-0.29.1 → vgplot-0.31.0}/README.md

@@ -50,18 +50,30 @@ brush = vg.selection.crossfilter()
 
 view = vg.vconcat(
     vg.plot(
-        vg.rect_y(flights, x=vg.bin("delay"), y=vg.count(),
-                  filter_by=brush, fill="steelblue",
-                  inset_left=0.5, inset_right=0.5),
+        vg.rect_y(
+            flights,
+            x=vg.bin("delay"),
+            y=vg.count(),
+            filter_by=brush,
+            fill="steelblue",
+            inset_left=0.5,
+            inset_right=0.5,
+        ),
         vg.interval_x(bind=brush),
         vg.x_domain("Fixed"),
         vg.x_label("Arrival Delay (min)"),
         vg.height(200),
     ),
     vg.plot(
-        vg.rect_y(flights, x=vg.bin("time"), y=vg.count(),
-                  filter_by=brush, fill="steelblue",
-                  inset_left=0.5, inset_right=0.5),
+        vg.rect_y(
+            flights,
+            x=vg.bin("time"),
+            y=vg.count(),
+            filter_by=brush,
+            fill="steelblue",
+            inset_left=0.5,
+            inset_right=0.5,
+        ),
         vg.interval_x(bind=brush),
         vg.x_domain("Fixed"),
         vg.x_label("Departure Time (hour)"),
@@ -85,9 +97,7 @@ bias = vg.param(0)
 view = vg.vconcat(
     vg.slider(label="Bias", bind=bias, min=0, max=1000, step=1),
     vg.plot(
-        vg.area_y(walk, x="t", y=vg.sql("v + $bias")),
-        vg.width(680),
-        vg.height(200),
+        vg.area_y(walk, x="t", y=vg.sql("v + $bias")), vg.width(680), vg.height(200)
     ),
 )
 

{vgplot-0.29.1 → vgplot-0.31.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vgplot-python",
-  "version": "0.29.1",
+  "version": "0.31.0",
   "private": true,
   "scripts": {
     "prerelease": "uv run ruff check && uv run ruff format --check",

{vgplot-0.29.1 → vgplot-0.31.0}/pyproject.toml

@@ -31,7 +31,3 @@ pattern = "\"version\": \"(?P<version>.+?)\""
 
 [tool.hatch.build.targets.wheel]
 packages = ["vgplot"]
-
-[tool.pyright]
-ignore = ["../**/.venv/"]  # Do not display diagnostics in external source code
-typeCheckingMode = "standard"

{vgplot-0.29.1/test → vgplot-0.31.0/tests}/test_full_round_trip.py

@@ -3,48 +3,44 @@
 # in specs/json/. Also checks that Python, JSON, and ESM example sets stay
 # in sync (same filenames).
 #
-# Run: pytest packages/vgplot/vgplot-python/test/test_full_round_trip.py
+# Run: pytest packages/vgplot/vgplot-python/tests/test_full_round_trip.py
+from __future__ import annotations
+
 import json
-import sys
 from pathlib import Path
 from typing import Any
 
 import pytest
 
-ROOT = Path(__file__).resolve().parents[4]  # mosaic project root
-SPEC_DIR = ROOT / "specs"
+SPEC_DIR = Path(__file__).resolve().parents[4] / "specs"
 JSON_DIR = SPEC_DIR / "json"
 ESM_DIR = SPEC_DIR / "esm"
 PYTHON_DIR = SPEC_DIR / "python"
 
-VGPLOT_PKG = ROOT / "packages" / "vgplot" / "vgplot-python"
-
-for p in (VGPLOT_PKG, ROOT):
-    if str(p) not in sys.path:
-        sys.path.insert(0, str(p))
-
 
-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__"]
 
 
@@ -53,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.29.1/test → vgplot-0.31.0/tests}/test_python_api.py

@@ -1,25 +1,19 @@
 # Unit tests for the vgplot Python API, covering behaviors that the
 # generated-spec round-trip suite does not exercise directly.
-import sys
-from pathlib import Path
+from __future__ import annotations
 
-import pytest
-
-ROOT = Path(__file__).resolve().parents[4]
-VGPLOT_PKG = ROOT / "packages" / "vgplot" / "vgplot-python"
-for p in (VGPLOT_PKG, ROOT):
-    if str(p) not in sys.path:
-        sys.path.insert(0, str(p))
+from typing import TYPE_CHECKING
 
-import vgplot as vg  # noqa: E402
-from vgplot.plot import Mark  # noqa: E402
+import pytest
+import vgplot as vg
+from vgplot.plot import Mark
 
 
 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": ""})
@@ -29,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)
@@ -86,7 +80,8 @@ 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
 
         weather = pa.table({"a": [1, 2, 3]})
@@ -96,7 +91,8 @@ 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
 
         weather = pa.table({"a": [1]})
@@ -108,3 +104,17 @@ class TestDataFrames:
         assert d["plot"][1]["data"] == {"from": "athletes"}
         assert d["data"]["weather"] is weather
         assert d["data"]["athletes"] == {"type": "csv", "file": "athletes.csv"}
+
+
+if TYPE_CHECKING:
+
+    def typing_dunder_all() -> None:
+        # Ok
+        _ = 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]

vgplot-0.31.0/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.31.0/tests/test_unset_sentinel.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import copy
+from typing import TYPE_CHECKING, Any, Union, get_type_hints
+
+if TYPE_CHECKING:
+    # NOTE: Don't move this into a runtime import (yet)
+    from vgplot._types import UNSET
+
+
+def _import_unset() -> UNSET:
+    # NOTE: A regular import would add:
+    # - `vgplot._types` to `sys.modules`
+    # - `UNSET` to `globals`
+    # And we can't use `importlib.reload`, since that would create a new object
+    from vgplot._types import UNSET
+
+    return UNSET
+
+
+def test_unset_identity() -> None:
+    unset_1 = _import_unset()
+    unset_2 = _import_unset()
+    assert unset_1 is unset_2
+
+
+def test_unset_repr() -> None:
+    assert repr(_import_unset()) == "UNSET"
+
+
+def test_unset_pickle() -> None:
+    import pickle
+
+    unset = _import_unset()
+    assert pickle.loads(pickle.dumps(unset)) is unset
+
+
+def test_unset_type_expression_union() -> None:
+    # Adapted from https://github.com/python/typing_extensions/blob/83400e979b8e3b0b647f9a6a57f0275230e5f19f/src/test_typing_extensions.py#L9694-L9701
+    from vgplot._types import UNSET
+
+    def func1(a: int | UNSET = UNSET) -> None: ...
+    def func2(a: UNSET | int = UNSET) -> None: ...
+
+    assert get_type_hints(func1, localns=locals())["a"] == Union[int, UNSET]  # noqa: UP007
+    assert get_type_hints(func2, localns=locals())["a"] == Union[UNSET, int]  # noqa: UP007
+
+
+def test_unset_copy_identity() -> None:
+    # Adapted from https://github.com/python/typing_extensions/blob/83400e979b8e3b0b647f9a6a57f0275230e5f19f/src/test_typing_extensions.py#L9711-L9713
+    unset = _import_unset()
+    assert unset is copy.copy(unset)
+    assert unset is copy.deepcopy(unset)
+
+
+def test_unset_union_identity() -> None:
+    unset = _import_unset()
+    assert (unset | unset) is unset
+
+
+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
+    ) -> None:
+        assert_type(a, UNSET)
+        assert_type(b, str | UNSET)
+        assert_type(c, Any | UNSET)
+        assert_type(d, int | None | UNSET)

{vgplot-0.29.1 → vgplot-0.31.0}/vgplot/__init__.py

@@ -1,50 +1,52 @@
-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_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,
+    vconcat,
+    vspace,
 )
-from ._generated import *  # noqa: F401, F403
-from ._generated import __all__ as _generated_all
+from .spec import Spec, View, spec
 
 __all__ = [
     "Spec",

vgplot-0.31.0/vgplot/_compat.py

@@ -0,0 +1,101 @@
+"""Backwards compatibility for features not available at our [requires-python][1].
+
+Import from here to avoid introducing runtime dependency on [typing_extensions][2].
+
+[1]: https://packaging.python.org/en/latest/specifications/pyproject-toml/#requires-python
+[2]: https://github.com/python/typing_extensions
+
+## sentinel
+[`sentinel`][3] was introduced in `3.15` (see [PEP 661][4]).
+
+We can remove the backport after [3.15 end-of-life][5].
+
+[3]: https://docs.python.org/3.15/library/functions.html#sentinel
+[4]: https://peps.python.org/pep-0661/
+[5]: https://peps.python.org/pep-0790/#lifespan
+"""
+
+from __future__ import annotations
+
+import sys
+import typing
+from contextlib import suppress
+from importlib.util import find_spec
+from typing import TYPE_CHECKING, Any, ClassVar
+
+
+def _sentinel_backport_pre_typing_extensions_4_16() -> Any:
+    class _sentinel_backport:
+        """Create a unique sentinel object.
+
+        *name* should be the name of the variable to which the return value shall be assigned.
+        """
+
+        def __init__(self, name: str, /, *, repr: str | None = None) -> None:
+            self.__name__: str = name
+            self._repr: str = repr if repr is not None else name
+            # TODO @dangotbanned: Figure out why they didn't use the `"__main__"` default here?
+            module: str | None = None
+            if hasattr(sys, "_getframemodulename"):
+                module = sys._getframemodulename(1) or "__main__"
+            elif hasattr(sys, "_getframe"):
+                with suppress(ValueError):
+                    module = sys._getframe(1).f_globals.get("__name__", "__main__")
+
+            # For pickling as a singleton
+            self.__module__ = module  # pyright: ignore[reportAttributeAccessIssue] # ty: ignore[invalid-assignment]
+
+        __init_subclass__: ClassVar[None] = None
+
+        def __repr__(self) -> str:
+            return self._repr
+
+        if sys.version_info < (3, 11):
+            # The presence of this method convinces typing._type_check that Sentinels are types.
+            def __call__(self, *args: Any, **kwargs: Any) -> Any:
+                msg = f"{type(self).__name__!r} object is not callable"
+                raise TypeError(msg)
+
+        def __or__(self, other: Any) -> Any:
+            return typing.Union[self, other]  # noqa: UP007
+
+        def __ror__(self, other: Any) -> Any:
+            return typing.Union[other, self]  # noqa: UP007
+
+        def __reduce__(self) -> str:
+            return self.__name__
+
+    return _sentinel_backport
+
+
+def _sentinel_backport_pre_py_3_15() -> Any:
+    """Return a [PEP 661]-compatible [`sentinel`](https://docs.python.org/3.15/library/functions.html#sentinel) factory.
+
+    [PEP 661]: https://peps.python.org/pep-0661/
+
+    ## Notes
+    - Does not depend on `typing_extensions`, but will use it if a suitable version is available
+    - Fallback is adapted from [`typing_extensions==4.16.0`](https://github.com/python/typing_extensions/blob/f29cd28d8ed7642cafb1d18daf5aa41be6a5c0aa/src/typing_extensions.py#L176-L271)
+    """
+    if find_spec("typing_extensions"):
+        import typing_extensions
+
+        # NOTE: In the same release the name changed, this guy landed https://github.com/python/typing_extensions/pull/617
+        # `4.14-4.15` is fine for typing, but the runtime changes are too big to rely on
+        if hasattr(typing_extensions, "sentinel"):
+            return getattr(typing_extensions, "sentinel", typing_extensions.Sentinel)
+
+    return _sentinel_backport_pre_typing_extensions_4_16()
+
+
+if TYPE_CHECKING:
+    # Was renamed in https://github.com/python/typing_extensions/releases/tag/4.16.0
+    from typing_extensions import Sentinel as sentinel
+else:  # ruff: ignore[collapsible-else-if]
+    if sys.version_info >= (3, 15):
+        from builtins import sentinel
+    else:
+        sentinel = _sentinel_backport_pre_py_3_15()
+
+
+__all__ = ("sentinel",)

{vgplot-0.29.1 → vgplot-0.31.0}/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]
+__all__ = [*_mark_all, *_attr_all, *_enc_all]  # pyright: ignore[reportUnsupportedDunderAll]  # ruff: ignore[invalid-all-object]