perspective-python 4.5.2__cp311-abi3-pyemscripten_2025_0_wasm32.whl

perspective/tests/test_dependencies.py

@@ -0,0 +1,53 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 pytest
+
+
+# test that loading perspective and calling a common constructor code path does
+# not load various "expensive" modules. "Expensive" is in quotes because this is
+# utter nonsense.
+@pytest.mark.skip(reason="https://github.com/pyca/bcrypt/issues/694")
+def test_lazy_modules():
+    import sys
+
+    cache = {}
+    for key in list(sys.modules.keys()):
+        if (
+            key.startswith("perspective")
+            or key.startswith("test")
+            or key.startswith("pandas")
+            or key.startswith("pyarrow")
+            or key.startswith("tornado")
+        ):
+            cache[key] = sys.modules[key]
+            del sys.modules[key]
+
+    import perspective
+
+    t1 = perspective.table("x\n1")
+    t1.delete()
+
+    assert "perspective" in sys.modules
+    assert "pandas" not in sys.modules
+    assert "pyarrow" not in sys.modules
+    assert "tornado" not in sys.modules
+
+    for k, v in cache.items():
+        sys.modules[k] = v
+
+
+def test_all():
+    import perspective
+
+    for key in perspective.__all__:
+        assert hasattr(perspective, key)

perspective/tests/viewer/__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/viewer/test_viewer.py

@@ -0,0 +1,246 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 numpy as np
+import pandas as pd
+import pytest
+from perspective.widget.viewer import PerspectiveViewer
+import perspective as psp
+
+client = psp.Server().new_local_client()
+Table = client.table
+
+
+class TestViewer:
+    def test_viewer_get_table(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        assert viewer.table == table
+
+    # loading
+
+    def test_viewer_load_table(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        assert viewer.columns == ["a"]
+
+    def test_viewer_load_named_table(self):
+        table = Table({"a": [1, 2, 3]}, name="data_1")
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        assert viewer.columns == ["a"]
+        assert viewer.table_name == "data_1"
+        assert viewer.table == table
+
+    def test_viewer_load_data(self):
+        viewer = PerspectiveViewer()
+        viewer.load({"a": [1, 2, 3]})
+        assert viewer.columns == ["a"]
+
+    def test_viewer_load_named_data(self):
+        viewer = PerspectiveViewer()
+        viewer.load({"a": [1, 2, 3]}, name="data_1")
+        assert viewer.columns == ["a"]
+        assert viewer.table_name == "data_1"
+
+    def test_viewer_load_schema(self):
+        viewer = PerspectiveViewer()
+        viewer.load({"a": "string", "b": "integer", "c": "boolean", "d": "string"})
+        for col in viewer.columns:
+            assert col in ["a", "b", "c", "d"]
+
+    def test_viewer_load_table_with_options(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer()
+        # options should be disregarded when loading Table
+        viewer.load(table, limit=1)
+        assert viewer.columns == ["a"]
+        assert viewer.table.size() == 3
+
+    def test_viewer_load_data_with_options(self):
+        viewer = PerspectiveViewer()
+        # options should be forwarded to the Table constructor
+        viewer.load({"a": [1, 2, 3]}, limit=1)
+        assert viewer.columns == ["a"]
+        assert viewer.table.size() == 1
+
+    def test_viewer_load_clears_state(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer(theme="Pro Dark", group_by=["a"])
+        viewer.load(table)
+        assert viewer.group_by == ["a"]
+        viewer.load({"b": [1, 2, 3]})
+        assert viewer.group_by == []
+        assert viewer.theme == "Pro Dark"  # should not break UI
+
+    @pytest.mark.skip
+    def test_viewer_load_np(self):
+        table = Table({"a": np.arange(1, 100)})
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        assert viewer.columns == ["a"]
+
+    @pytest.mark.skip
+    def test_viewer_load_np_data(self):
+        viewer = PerspectiveViewer()
+        viewer.load({"a": np.arange(1, 100)})
+        assert viewer.columns == ["a"]
+        assert viewer.table.size() == 99
+
+    @pytest.mark.skip
+    def test_viewer_load_df(self):
+        table = Table(pd.DataFrame({"a": np.arange(1, 100)}))
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        for col in viewer.columns:
+            assert col in ["index", "a"]
+        assert viewer.table.size() == 99
+
+    def test_viewer_load_df_data(self):
+        viewer = PerspectiveViewer()
+        viewer.load(pd.DataFrame({"a": np.arange(1, 100)}))
+        for col in viewer.columns:
+            assert col in ["index", "a"]
+
+    # update
+
+    def test_viewer_update_dict(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        viewer.update({"a": [4, 5, 6]})
+        assert table.size() == 6
+        assert viewer.table.size() == 6
+        assert viewer.table.view().to_columns() == {"a": [1, 2, 3, 4, 5, 6]}
+
+    def test_viewer_update_list(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        viewer.update([{"a": 4}, {"a": 5}, {"a": 6}])
+        assert table.size() == 6
+        assert viewer.table.size() == 6
+        assert viewer.table.view().to_columns() == {"a": [1, 2, 3, 4, 5, 6]}
+
+    def test_viewer_update_df(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        viewer.update(pd.DataFrame({"a": [4, 5, 6]}))
+        assert table.size() == 6
+        assert viewer.table.size() == 6
+        assert viewer.table.view().to_columns() == {"a": [1, 2, 3, 4, 5, 6]}
+
+    def test_viewer_update_dict_partial(self):
+        table = Table({"a": [1, 2, 3], "b": [5, 6, 7]}, index="a")
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        viewer.update({"a": [1, 2, 3], "b": [8, 9, 10]})
+        assert table.size() == 3
+        assert viewer.table.size() == 3
+        assert viewer.table.view().to_columns() == {"a": [1, 2, 3], "b": [8, 9, 10]}
+
+    # clear
+
+    def test_viewer_clear(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        viewer.clear()
+        assert viewer.table.size() == 0
+        assert viewer.table.schema() == {"a": "integer"}
+
+    # replace
+
+    def test_viewer_replace(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer()
+        viewer.load(table)
+        viewer.replace({"a": [4, 5, 6]})
+        assert viewer.table.size() == 3
+        assert viewer.table.schema() == {"a": "integer"}
+        assert viewer.table.view().to_columns() == {"a": [4, 5, 6]}
+
+    # reset
+
+    def test_viewer_reset(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer(plugin="X Bar", filter=[["a", "==", 2]])
+        viewer.load(table)
+        assert viewer.filter == [["a", "==", 2]]
+        viewer.reset()
+        assert viewer.plugin == "Datagrid"
+        assert viewer.filter == []
+
+    # delete
+
+    def test_viewer_delete(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer(plugin="X Bar", filter=[["a", "==", 2]])
+        viewer.load(table)
+        assert viewer.filter == [["a", "==", 2]]
+        viewer.delete()
+        assert viewer.table_name is None
+        assert viewer.table is None
+
+    def test_viewer_delete_without_table(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer(plugin="X Bar", filter=[["a", "==", 2]])
+        viewer.load(table)
+        assert viewer.filter == [["a", "==", 2]]
+        viewer.delete(delete_table=False)
+        assert viewer.table_name is not None
+        assert viewer.table is not None
+        assert viewer.filter == []
+
+    def test_save_restore(self):
+        table = Table({"a": [1, 2, 3]})
+        viewer = PerspectiveViewer(
+            plugin="X Bar", filter=[["a", "==", 2]], expressions={'"a" * 2': '"a" * 2'}
+        )
+        viewer.load(table)
+
+        # Save config
+        config = viewer.save()
+        assert viewer.filter == [["a", "==", 2]]
+        assert config["filter"] == [["a", "==", 2]]
+        assert viewer.plugin == "X Bar"
+        assert config["plugin"] == "X Bar"
+        assert config["expressions"] == {'"a" * 2': '"a" * 2'}
+
+        # reset configuration
+        viewer.reset()
+        assert viewer.plugin == "Datagrid"
+        assert viewer.filter == []
+        assert viewer.expressions == {}
+
+        # restore configuration
+        viewer.restore(**config)
+        assert viewer.filter == [["a", "==", 2]]
+        assert viewer.plugin == "X Bar"
+        assert viewer.expressions == {'"a" * 2': '"a" * 2'}
+
+    def test_save_restore_plugin_config(self):
+        viewer = PerspectiveViewer(
+            plugin="Datagrid", plugin_config={"columns": {"a": {"fixed": 4}}}
+        )
+        config = viewer.save()
+
+        assert config["plugin_config"] == {"columns": {"a": {"fixed": 4}}}
+
+        viewer.reset()
+        assert viewer.plugin_config == {}
+
+        viewer.restore(**config)
+        assert viewer.plugin_config == config["plugin_config"]

perspective/tests/virtual_servers/__init__.py

@@ -0,0 +1,12 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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/virtual_servers/test_coerce_types.py

@@ -0,0 +1,209 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 io
+import json
+from decimal import Decimal
+
+import pyarrow as pa
+import pyarrow.ipc as ipc
+
+from perspective import VirtualDataSlice
+
+
+def round_trip(arrow_table):
+    """Serialize a PyArrow table to IPC, feed through VirtualDataSlice, read back as JSON."""
+    buf = io.BytesIO()
+    with ipc.new_stream(buf, arrow_table.schema) as writer:
+        writer.write_table(arrow_table)
+    ds = VirtualDataSlice()
+    ds.from_arrow_ipc(buf.getvalue())
+    return json.loads(ds.render_to_columns_json())
+
+
+class TestCoerceSmallIntegers:
+    def test_coerce_int8(self):
+        table = pa.table({"col": pa.array([-1, 127, None], type=pa.int8())})
+        result = round_trip(table)
+        assert result["col"] == [-1, 127, None]
+
+    def test_coerce_int16(self):
+        table = pa.table({"col": pa.array([-300, 32000, None], type=pa.int16())})
+        result = round_trip(table)
+        assert result["col"] == [-300, 32000, None]
+
+
+class TestCoerceUnsignedIntegers:
+    def test_coerce_uint8(self):
+        table = pa.table({"col": pa.array([0, 255, None], type=pa.uint8())})
+        result = round_trip(table)
+        assert result["col"] == [0, 255, None]
+
+    def test_coerce_uint16(self):
+        table = pa.table({"col": pa.array([0, 65535, None], type=pa.uint16())})
+        result = round_trip(table)
+        assert result["col"] == [0, 65535, None]
+
+    def test_coerce_uint32(self):
+        table = pa.table({"col": pa.array([0, 4_294_967_295, None], type=pa.uint32())})
+        result = round_trip(table)
+        assert result["col"] == [0.0, 4_294_967_295.0, None]
+
+    def test_coerce_uint64(self):
+        table = pa.table({"col": pa.array([0, 1 << 53, None], type=pa.uint64())})
+        result = round_trip(table)
+        assert result["col"] == [0.0, 9_007_199_254_740_992.0, None]
+
+
+class TestCoerceFloat32:
+    def test_coerce_float32(self):
+        table = pa.table({"col": pa.array([3.14, -0.0, None], type=pa.float32())})
+        result = round_trip(table)
+        assert abs(result["col"][0] - 3.14) < 0.001
+        assert result["col"][1] == 0.0
+        assert result["col"][2] is None
+
+
+class TestCoerceDate64:
+    def test_coerce_date64(self):
+        day = 19738
+        table = pa.table({"col": pa.array([day * 86_400_000, None], type=pa.date64())})
+        result = round_trip(table)
+        assert result["col"] == [day * 86_400_000, None]
+
+
+class TestCoerceTime:
+    def test_coerce_time32_second(self):
+        table = pa.table({"col": pa.array([49530, None], type=pa.time32("s"))})
+        result = round_trip(table)
+        assert result["col"] == [49_530_000, None]
+
+    def test_coerce_time32_millisecond(self):
+        table = pa.table({"col": pa.array([49_530_000, None], type=pa.time32("ms"))})
+        result = round_trip(table)
+        assert result["col"] == [49_530_000, None]
+
+    def test_coerce_time64_microsecond(self):
+        table = pa.table(
+            {"col": pa.array([49_530_000_000, None], type=pa.time64("us"))}
+        )
+        result = round_trip(table)
+        assert result["col"] == [49_530_000, None]
+
+    def test_coerce_time64_nanosecond(self):
+        table = pa.table(
+            {"col": pa.array([49_530_000_000_000, None], type=pa.time64("ns"))}
+        )
+        result = round_trip(table)
+        assert result["col"] == [49_530_000, None]
+
+
+class TestCoerceLargeUtf8:
+    def test_coerce_large_utf8(self):
+        table = pa.table({"col": pa.array(["hello", "", None], type=pa.large_utf8())})
+        result = round_trip(table)
+        assert result["col"] == ["hello", "", None]
+
+
+class TestCoerceDecimal128:
+    def test_coerce_decimal128(self):
+        arr = pa.array([Decimal("1234.5678"), None], type=pa.decimal128(10, 4))
+        table = pa.table({"col": arr})
+        result = round_trip(table)
+        assert result["col"] == [1234.5678, None]
+
+
+class TestCoerceInt64:
+    def test_coerce_int64(self):
+        table = pa.table({"col": pa.array([1, -1, None], type=pa.int64())})
+        result = round_trip(table)
+        assert result["col"] == [1.0, -1.0, None]
+
+
+class TestCoerceTimestamp:
+    def test_coerce_timestamp_second(self):
+        table = pa.table({"col": pa.array([1000, None], type=pa.timestamp("s"))})
+        result = round_trip(table)
+        assert result["col"] == [1_000_000, None]
+
+    def test_coerce_timestamp_microsecond(self):
+        table = pa.table({"col": pa.array([1_000_000, None], type=pa.timestamp("us"))})
+        result = round_trip(table)
+        assert result["col"] == [1000, None]
+
+    def test_coerce_timestamp_nanosecond(self):
+        table = pa.table(
+            {"col": pa.array([1_000_000_000, None], type=pa.timestamp("ns"))}
+        )
+        result = round_trip(table)
+        assert result["col"] == [1000, None]
+
+
+class TestPassthrough:
+    def test_passthrough_bool(self):
+        table = pa.table({"col": pa.array([True, False, None], type=pa.bool_())})
+        result = round_trip(table)
+        assert result["col"] == [True, False, None]
+
+    def test_passthrough_utf8(self):
+        table = pa.table({"col": pa.array(["a", "b", None], type=pa.utf8())})
+        result = round_trip(table)
+        assert result["col"] == ["a", "b", None]
+
+    def test_passthrough_float64(self):
+        table = pa.table({"col": pa.array([1.5, -2.5, None], type=pa.float64())})
+        result = round_trip(table)
+        assert result["col"] == [1.5, -2.5, None]
+
+    def test_passthrough_int32(self):
+        table = pa.table({"col": pa.array([1, -1, None], type=pa.int32())})
+        result = round_trip(table)
+        assert result["col"] == [1, -1, None]
+
+    def test_passthrough_date32(self):
+        table = pa.table({"col": pa.array([19738, None], type=pa.date32())})
+        result = round_trip(table)
+        assert result["col"] == [19738 * 86_400_000, None]
+
+    def test_passthrough_timestamp_millisecond(self):
+        table = pa.table({"col": pa.array([1000, None], type=pa.timestamp("ms"))})
+        result = round_trip(table)
+        assert result["col"] == [1000, None]
+
+
+class TestFallback:
+    def test_fallback_fixed_size_binary(self):
+        table = pa.table(
+            {"col": pa.array([b"\x01\x02", b"\x03\x04", None], type=pa.binary(2))}
+        )
+        result = round_trip(table)
+        col = result["col"]
+        assert isinstance(col[0], str)
+        assert isinstance(col[1], str)
+        assert col[0] != col[1]
+        assert col[2] is None
+
+
+class TestEmpty:
+    def test_empty_batch(self):
+        # PyArrow's new_stream with an empty table writes no record batches,
+        # so we use RecordBatchStreamWriter directly to produce a valid empty batch.
+        schema = pa.schema([("col", pa.int8())])
+        batch = pa.record_batch({"col": pa.array([], type=pa.int8())})
+        buf = io.BytesIO()
+        writer = ipc.RecordBatchStreamWriter(buf, schema)
+        writer.write_batch(batch)
+        writer.close()
+        ds = VirtualDataSlice()
+        ds.from_arrow_ipc(buf.getvalue())
+        result = json.loads(ds.render_to_columns_json())
+        assert result["col"] == []