perspective-python 5.6.0__cp311-abi3-pyemscripten_2026_0_wasm32.whl

perspective/tests/widget/__init__.py

@@ -0,0 +1,11 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

perspective/tests/widget/test_anywidget_smoke.py

@@ -0,0 +1,109 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+import pathlib
+
+import anywidget
+import pytest
+
+import perspective.widget as widget_module
+from perspective.widget import PerspectiveWidget
+
+pytestmark = pytest.mark.filterwarnings("ignore::DeprecationWarning")
+
+_STATIC = pathlib.Path(widget_module.__file__).parent / "static"
+
+
+class TestAnyWidgetSmoke:
+    def test_instantiates_outside_jupyterlab(self):
+        widget = PerspectiveWidget({"a": [1, 2, 3, 4, 5]}, plugin="X Bar")
+        assert isinstance(widget, anywidget.AnyWidget)
+        assert widget.plugin == "X Bar"
+
+    def test_traits_round_trip(self):
+        widget = PerspectiveWidget(
+            {"a": [1, 2, 3]}, group_by=["a"], sort=[["a", "desc"]]
+        )
+        assert widget.group_by == ["a"]
+        assert widget.sort == [["a", "desc"]]
+        widget.split_by = ["a"]
+        assert widget.split_by == ["a"]
+
+    def test_columns_config_and_group_rollup_mode(self):
+        widget = PerspectiveWidget({"a": [1, 2, 3]})
+        assert widget.columns_config == {}
+        assert widget.group_rollup_mode == "rollup"
+        assert PerspectiveWidget.columns_config.metadata.get("sync") is True
+        assert PerspectiveWidget.group_rollup_mode.metadata.get("sync") is True
+
+        widget = PerspectiveWidget(
+            {"a": [1, 2, 3]},
+            columns_config={"a": {"fg_mode": "bar"}},
+            group_rollup_mode="flat",
+        )
+        assert widget.columns_config == {"a": {"fg_mode": "bar"}}
+        assert widget.group_rollup_mode == "flat"
+
+    def test_frontend_state_update_applies_with_version(self):
+        widget = PerspectiveWidget({"a": [1, 2, 3]})
+        widget.set_state(
+            {
+                "plugin": "X Bar",
+                "columns": ["a"],
+                "group_by": ["a"],
+                "settings": False,
+                "theme": "Pro Dark",
+                "version": "0.0.0",
+            }
+        )
+
+        assert widget.plugin == "X Bar"
+        assert widget.columns == ["a"]
+        assert widget.group_by == ["a"]
+        assert widget.settings is False
+        assert widget.theme == "Pro Dark"
+        assert widget.version == "0.0.0"
+
+    def test_not_a_labextension_widget(self):
+        widget = PerspectiveWidget({"a": [1, 2, 3]})
+        assert widget._model_module == "anywidget"
+        assert widget._view_module == "anywidget"
+        for attr in (
+            "_model_module",
+            "_view_module",
+            "_model_name",
+            "_view_name",
+        ):
+            assert getattr(widget, attr, "") != "@perspective-dev/jupyterlab"
+
+    def test_esm_css_configured(self):
+        assert PerspectiveWidget._esm is not None
+        assert PerspectiveWidget._css is not None
+
+    def test_bundle_is_packaged(self):
+        esm = _STATIC / "perspective-anywidget.js"
+        css = _STATIC / "perspective-anywidget.css"
+        if not esm.exists():
+            pytest.skip("anywidget bundle not built in this environment")
+        assert esm.stat().st_size > 0
+        assert css.exists() and css.stat().st_size > 0
+
+    def test_proxy_session_lifecycle(self):
+        widget = PerspectiveWidget({"a": [1, 2, 3]})
+        widget.handle_message(widget, {"type": "connect", "client_id": "c1"}, [])
+        assert "c1" in widget._sessions
+        widget.handle_message(widget, {"type": "hangup", "client_id": "c1"}, [])
+        assert "c1" not in widget._sessions
+
+    def test_deferred_load_without_data(self):
+        widget = PerspectiveWidget(None, group_by=["a"])
+        assert widget.group_by == ["a"]

perspective/tests/widget/test_widget.py

@@ -0,0 +1,278 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+from functools import partial
+from types import MethodType
+import numpy as np
+from perspective.widget import PerspectiveWidget
+from pytest import raises
+import pytest
+import perspective as psp
+
+client = psp.Server().new_local_client()
+Table = client.table
+
+pytest.skip(allow_module_level=True)
+
+
+def mock_post(self, msg, msg_id=None, assert_msg=None):
+    """Mock the widget's `post()` method so we can introspect the contents."""
+    assert msg == assert_msg
+
+
+class TestWidget:
+    def test_widget(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data, plugin="X Bar")
+        assert widget.plugin == "X Bar"
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name, "options": {}},
+        }
+
+    def test_widget_indexed(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data, plugin="X Bar", index="a")
+        assert widget.plugin == "X Bar"
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name, "options": {"index": "a"}},
+        }
+
+    def test_widget_no_data(self):
+        widget = PerspectiveWidget(None, plugin="X Bar", group_by=["a"])
+        assert widget.plugin == "X Bar"
+        assert widget.group_by == ["a"]
+
+    def test_widget_schema(self):
+        schema = {
+            "a": "integer",
+            "b": "float",
+            "c": "boolean",
+            "d": "date",
+            "e": "datetime",
+            "f": "string",
+        }
+        widget = PerspectiveWidget(schema)
+        assert widget.table.schema() == schema
+
+    def test_widget_schema_with_index(self):
+        widget = PerspectiveWidget({"a": "integer"}, index="a")
+        assert widget.table.get_index() == "a"
+
+    def test_widget_schema_with_limit(self):
+        widget = PerspectiveWidget({"a": "integer"}, limit=5)
+        assert widget.table.get_limit() == 5
+
+    def test_widget_no_data_with_index(self):
+        # should fail
+        with raises(TypeError):
+            PerspectiveWidget(None, index="a")
+
+    def test_widget_no_data_with_limit(self):
+        # should fail
+        with raises(TypeError):
+            PerspectiveWidget(None, limit=5)
+
+    def test_widget_eventual_data(self):
+        table = Table({"a": np.arange(0, 50)})
+        widget = PerspectiveWidget(None, plugin="X Bar")
+        assert widget.plugin == "X Bar"
+
+        with raises(TypeError):
+            widget._make_load_message()
+
+        widget.load(table)
+
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name, "options": {}},
+        }
+
+    def test_widget_eventual_data_server(self):
+        widget = PerspectiveWidget(None, plugin="X Bar", server=True)
+        assert widget.plugin == "X Bar"
+        widget.load({"a": np.arange(0, 50)}, index="a")
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {
+                "table_name": widget.table_name,
+            },
+        }
+
+    def test_widget_eventual_data_indexed(self):
+        widget = PerspectiveWidget(None, plugin="X Bar")
+        assert widget.plugin == "X Bar"
+        widget.load({"a": np.arange(0, 50)}, index="a")
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name, "options": {"index": "a"}},
+        }
+
+    def test_widget_eventual_table_indexed(self):
+        table = Table({"a": np.arange(0, 50)}, index="a")
+        widget = PerspectiveWidget(None, plugin="X Bar")
+        assert widget.plugin == "X Bar"
+        widget.load(table)
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name, "options": {"index": "a"}},
+        }
+
+    def test_widget_load_table(self):
+        table = Table({"a": np.arange(0, 50)})
+        widget = PerspectiveWidget(table, plugin="X Bar")
+        assert widget.plugin == "X Bar"
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name, "options": {}},
+        }
+
+    def test_widget_load_table_indexed(self):
+        table = Table({"a": np.arange(0, 50)}, index="a")
+        widget = PerspectiveWidget(table, plugin="X Bar")
+        assert widget.plugin == "X Bar"
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name, "options": {"index": "a"}},
+        }
+
+    def test_widget_load_table_ignore_limit(self):
+        table = Table({"a": np.arange(0, 50)})
+        widget = PerspectiveWidget(table, limit=1)
+        assert widget.table.size() == 50
+
+    def test_widget_pass_index(self):
+        data = {"a": [1, 2, 3, 1]}
+        widget = PerspectiveWidget(data, index="a")
+        assert widget.table.size() == 3
+
+    def test_widget_pass_limit(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data, limit=1)
+        assert widget.table.size() == 1
+
+    def test_widget_pass_options_invalid(self):
+        data = {"a": np.arange(0, 50)}
+        with raises(TypeError):
+            PerspectiveWidget(data, index="index", limit=1)
+
+    # server mode
+    def test_widget_load_table_server(self):
+        table = Table({"a": np.arange(0, 50)})
+        widget = PerspectiveWidget(table, server=True)
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name},
+        }
+
+    def test_widget_no_data_with_server(self):
+        # should fail
+        widget = PerspectiveWidget(None, server=True)
+        with raises(TypeError):
+            widget._make_load_message()
+
+    def test_widget_eventual_data_with_server(self):
+        # should fail
+        widget = PerspectiveWidget(None, server=True)
+
+        with raises(TypeError):
+            widget._make_load_message()
+
+        # then succeed
+        widget.load(Table({"a": np.arange(0, 50)}))
+        load_msg = widget._make_load_message()
+        assert load_msg.to_columns() == {
+            "id": -2,
+            "type": "table",
+            "data": {"table_name": widget.table_name},
+        }
+
+    # clear
+
+    def test_widget_clear(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data)
+        widget.clear()
+        assert widget.table.size() == 0
+
+    def test_widget_clear_server(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data, server=True)
+        widget.clear()
+        assert widget.table.size() == 0
+
+    # replace
+
+    def test_widget_replace(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data)
+        widget.replace({"a": [1]})
+        assert widget.table.size() == 1
+
+    def test_widget_replace_server(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data, server=True)
+        widget.replace({"a": [1]})
+        assert widget.table.size() == 1
+
+    # delete
+
+    def test_widget_delete(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data)
+        mocked_post = partial(mock_post, assert_msg={"cmd": "delete"})
+        widget.post = MethodType(mocked_post, widget)
+        widget.delete()
+        assert widget.table is None
+
+    def test_widget_delete_with_view(self):
+        data = {"a": np.arange(0, 50)}
+        widget = PerspectiveWidget(data)
+
+        # create a view on the manager
+        table_name, table = list(widget.manager._tables.items())[0]
+        make_view_message = {
+            "id": 1,
+            "table_name": table_name,
+            "view_name": "view1",
+            "cmd": "view",
+            "config": {"group_by": ["a"]},
+        }
+        widget.manager._process(make_view_message, lambda x: True)
+
+        assert len(widget.manager._views) == 1
+
+        mocked_post = partial(mock_post, assert_msg={"cmd": "delete"})
+
+        widget.post = MethodType(mocked_post, widget)
+        widget.delete()
+
+        assert widget.table is None

perspective/tests/widget/test_widget_html_export.py

@@ -0,0 +1,113 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+#  ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+#  ┃ This file is part of the Perspective library, distributed under the terms ┃
+#  ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+#  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+# Regression tests for static HTML export, based on the repro in
+# https://github.com/perspective-dev/perspective/issues/2846
+
+import base64
+import json
+import re
+
+import pandas as pd
+import pytest
+
+from perspective.widget import PerspectiveWidget, __version__
+
+pytestmark = pytest.mark.filterwarnings("ignore::DeprecationWarning")
+
+
+def make_widget():
+    df = pd.DataFrame(dict(x=[1.0, 2.0, 3.0], y=[1.0, 3.0, 2.0]))
+    return PerspectiveWidget(df)
+
+
+def export_html(widget):
+    bundle = widget._repr_mimebundle_()
+    data = bundle[0] if isinstance(bundle, tuple) else bundle
+    return data["text/html"]
+
+
+class TestWidgetHtmlExport:
+    @pytest.fixture(autouse=True)
+    def _enable_export(self, monkeypatch):
+        monkeypatch.setenv("PSP_JUPYTER_HTML_EXPORT", "1")
+
+    def test_disabled_without_env(self, monkeypatch):
+        monkeypatch.delenv("PSP_JUPYTER_HTML_EXPORT")
+        bundle = make_widget()._repr_mimebundle_()
+        data = bundle[0] if isinstance(bundle, tuple) else bundle
+        assert data is None or "text/html" not in data
+
+    def test_bundle_preserves_anywidget_view(self):
+        bundle = make_widget()._repr_mimebundle_()
+        assert isinstance(bundle, tuple)
+        data, _metadata = bundle
+        assert "text/html" in data
+        assert "application/vnd.jupyter.widget-view+json" in data
+
+    def test_viewer_id_is_quoted(self):
+        widget = make_widget()
+        html = export_html(widget)
+        assert f'const viewerId = "{widget.model_id}";' in html
+        assert f'id="perspective-envelope-{widget.model_id}"' in html
+
+    def test_viewer_attrs_is_json(self):
+        widget = make_widget()
+        html = export_html(widget)
+        match = re.search(r"const viewerAttrs = (\{.*?\});", html, re.S)
+        assert match is not None
+        attrs = json.loads(match.group(1))
+        assert attrs["columns"] == ["index", "x", "y"]
+        assert attrs == json.loads(json.dumps(widget.save()))
+
+    def test_worker_is_awaited_before_table(self):
+        html = export_html(make_widget())
+        assert 'await customElements.whenDefined("perspective-viewer");' in html
+        assert "const client = await perspective.worker();" in html
+        assert "const table = await client.table(data.buffer);" in html
+        assert "perspective.worker().table" not in html
+
+    def test_cdn_urls_use_5x_package_names(self):
+        html = export_html(make_widget())
+        urls = re.findall(r'(?:src|href)="([^"]+)"', html)
+        prefix = f"https://cdn.jsdelivr.net/npm/@perspective-dev"
+        assert urls == [
+            f"{prefix}/client@{__version__}/dist/cdn/perspective.js",
+            f"{prefix}/viewer@{__version__}/dist/cdn/perspective-viewer.js",
+            f"{prefix}/viewer-datagrid@{__version__}/dist/cdn/perspective-viewer-datagrid.js",
+            f"{prefix}/viewer-charts@{__version__}/dist/cdn/perspective-viewer-charts.js",
+            f"{prefix}/viewer@{__version__}/dist/css/themes.css",
+        ]
+
+    def test_arrow_payload_round_trips(self):
+        widget = make_widget()
+        html = export_html(widget)
+        match = re.search(
+            r'<script type="application/vnd.apache.arrow.file">(.*?)</script>',
+            html,
+            re.S,
+        )
+        assert match is not None
+        data = base64.b64decode("".join(match.group(1).split()))
+        table = widget.table.get_client().table(data)
+        try:
+            view = table.view()
+            try:
+                assert view.to_columns() == {
+                    "index": [0, 1, 2],
+                    "x": [1.0, 2.0, 3.0],
+                    "y": [1.0, 3.0, 2.0],
+                }
+            finally:
+                view.delete()
+        finally:
+            table.delete()