perspective-python 5.6.0__cp311-abi3-pyemscripten_2026_0_wasm32.whl

perspective/tests/table/test_on_remove.py

@@ -0,0 +1,140 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 perspective as psp
+
+client = psp.Server().new_local_client()
+Table = client.table
+
+data = [{"x": 1, "y": "a"}, {"x": 2, "y": "b"}, {"x": 3, "y": "c"}]
+
+
+def removed_indices(indices):
+    return Table(indices).view().to_records()
+
+
+class TestOnRemove(object):
+    def test_on_remove_fires_with_removed_index_values(self):
+        tbl = Table(data, index="x")
+        view = tbl.view()
+        calls = []
+        cid = view.on_remove(lambda port_id, indices: calls.append((port_id, indices)))
+        tbl.remove([2])
+        assert len(calls) == 1
+        assert calls[0][0] == 0
+        assert removed_indices(calls[0][1]) == [{"x": 2}]
+        view.remove_remove(cid)
+
+    def test_on_remove_string_index(self):
+        tbl = Table(data, index="y")
+        view = tbl.view()
+        calls = []
+        cid = view.on_remove(lambda port_id, indices: calls.append(indices))
+        tbl.remove(["b", "c"])
+        assert len(calls) == 1
+        assert removed_indices(calls[0]) == [{"y": "b"}, {"y": "c"}]
+        view.remove_remove(cid)
+
+    def test_on_remove_ignores_unknown_and_update(self):
+        tbl = Table(data, index="x")
+        view = tbl.view()
+        calls = []
+        cid = view.on_remove(lambda port_id, indices: calls.append(indices))
+        tbl.remove([9])
+        tbl.update([{"x": 1, "y": "aa"}, {"x": 4, "y": "d"}])
+        assert tbl.size() == 4
+        assert calls == []
+        tbl.remove([3])
+        assert len(calls) == 1
+        assert removed_indices(calls[0]) == [{"x": 3}]
+        view.remove_remove(cid)
+
+    def test_on_remove_replace_reports_keys_not_resupplied(self):
+        tbl = Table(data, index="x")
+        view = tbl.view()
+        calls = []
+        cid = view.on_remove(lambda port_id, indices: calls.append(indices))
+        tbl.replace([{"x": 2, "y": "bb"}, {"x": 4, "y": "d"}])
+        assert len(calls) == 1
+        assert removed_indices(calls[0]) == [{"x": 1}, {"x": 3}]
+        assert view.to_records() == [{"x": 2, "y": "bb"}, {"x": 4, "y": "d"}]
+        view.remove_remove(cid)
+
+    def test_on_remove_clear_reports_every_key(self):
+        tbl = Table(data, index="x")
+        view = tbl.view()
+        calls = []
+        updates = []
+        cid = view.on_remove(lambda port_id, indices: calls.append(indices))
+        view.on_update(lambda port_id: updates.append(port_id))
+        tbl.clear()
+        assert len(calls) == 1
+        assert removed_indices(calls[0]) == [{"x": 1}, {"x": 2}, {"x": 3}]
+        assert view.to_records() == []
+        assert updates == [0]
+        view.remove_remove(cid)
+
+    def test_remove_remove_stops_delivery(self):
+        tbl = Table(data, index="x")
+        view = tbl.view()
+        first = []
+        second = []
+        cid = view.on_remove(lambda port_id, indices: first.append(indices))
+        view.remove_remove(cid)
+        cid2 = view.on_remove(lambda port_id, indices: second.append(indices))
+        tbl.remove([1])
+        assert first == []
+        assert len(second) == 1
+        view.remove_remove(cid2)
+
+    def test_remove_accepts_arrow(self):
+        tbl = Table(data, index="x")
+        arrow = Table({"x": [2, 3]}).view().to_arrow()
+        tbl.remove(arrow)
+        assert tbl.view().to_records() == [{"x": 1, "y": "a"}]
+
+    def test_table_from_view_inherits_index_and_replicates_removes(self):
+        tbl = Table(data, index="x")
+        view = tbl.view()
+        tbl2 = Table(view)
+        assert tbl2.get_index() == "x"
+        view2 = tbl2.view()
+
+        tbl.update([{"x": 2, "y": "bb"}])
+        assert tbl2.size() == 3
+        assert view2.to_records() == view.to_records()
+
+        tbl.remove([1])
+        assert tbl2.size() == 2
+        assert view2.to_records() == [{"x": 2, "y": "bb"}, {"x": 3, "y": "c"}]
+        assert view2.to_records() == view.to_records()
+
+    def test_table_from_view_mirrors_replace_and_clear(self):
+        tbl = Table(data, index="x")
+        view = tbl.view()
+        tbl2 = Table(view)
+        view2 = tbl2.view()
+
+        tbl.replace([{"x": 2, "y": "bb"}, {"x": 4, "y": "d"}])
+        assert view2.to_records() == [{"x": 2, "y": "bb"}, {"x": 4, "y": "d"}]
+
+        tbl.clear()
+        assert view2.to_records() == []
+
+        tbl.update([{"x": 5, "y": "e"}])
+        assert view2.to_records() == [{"x": 5, "y": "e"}]
+
+    def test_table_from_pivoted_view_stays_unindexed(self):
+        tbl = Table(data, index="x")
+        view = tbl.view(group_by=["y"])
+        tbl2 = Table(view)
+        assert tbl2.get_index() is None

perspective/tests/table/test_ports.py

@@ -0,0 +1,178 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 random
+import perspective as psp
+
+client = psp.Server().new_local_client()
+Table = client.table
+
+data = {"a": [1, 2, 3, 4], "b": ["a", "b", "c", "d"], "c": [True, False, True, False]}
+
+
+class TestPorts(object):
+    def test_make_port_sequential(self):
+        table = Table(data)
+        port_ids = []
+
+        for i in range(10):
+            port_ids.append(table.make_port())
+
+        assert port_ids == list(range(1, 11))
+
+    def test_make_port_sequential_and_update(self):
+        table = Table(data)
+        port_ids = []
+
+        for i in range(10):
+            port_ids.append(table.make_port())
+
+        assert port_ids == list(range(1, 11))
+
+        for i in range(1, 11):
+            table.update({"a": [i], "b": ["a"], "c": [True]}, port_id=i)
+
+        view = table.view()
+        result = view.to_columns()
+
+        assert result == {
+            "a": [1, 2, 3, 4] + [i for i in range(1, 11)],
+            "b": ["a", "b", "c", "d"] + ["a" for i in range(10)],
+            "c": [True, False, True, False] + [True for i in range(10)],
+        }
+
+    def test_arbitary_port_updates(self):
+        table = Table(data)
+        port_ids = []
+
+        for i in range(10):
+            port_ids.append(table.make_port())
+
+        assert port_ids == list(range(1, 11))
+
+        port = random.randint(0, 10)
+
+        table.update(data, port_id=port)
+
+        assert table.size() == 8
+
+        assert table.view().to_columns() == {
+            "a": [1, 2, 3, 4] * 2,
+            "b": ["a", "b", "c", "d"] * 2,
+            "c": [True, False, True, False] * 2,
+        }
+
+    def test_ports_should_only_notify_if_they_have_a_queued_update(self):
+        table = Table(data)
+        port_ids = []
+
+        for i in range(10):
+            port_ids.append(table.make_port())
+
+        assert port_ids == list(range(1, 11))
+
+        view = table.view()
+        ports_to_update = [random.randint(0, 10) for i in range(5)]
+
+        def callback(port_id):
+            assert port_id in ports_to_update
+
+        view.on_update(callback)
+
+        for port in ports_to_update:
+            table.update(data, port_id=port)
+
+    def test_ports_should_have_unique_deltas(self):
+        table = Table(data)
+        port_ids = []
+
+        for i in range(10):
+            port_ids.append(table.make_port())
+
+        assert port_ids == list(range(1, 11))
+
+        view = table.view()
+        ports_to_update = [random.randint(0, 10) for i in range(5)]
+        unique_data = {
+            port: [{"a": port, "b": str(port), "c": True}] for port in ports_to_update
+        }
+
+        def callback(port_id, delta):
+            assert port_id in ports_to_update
+            _t = Table(delta)
+            _v = _t.view()
+            assert _v.to_records() == unique_data[port]
+            _v.delete()
+            _t.delete()
+
+        view.on_update(callback, mode="row")
+
+        for port in ports_to_update:
+            table.update(unique_data[port], port_id=port)
+
+    def test_ports_should_queue_updates_properly(self):
+        table = Table(data)
+        port_ids = []
+
+        for i in range(10):
+            port_ids.append(table.make_port())
+
+        assert port_ids == list(range(1, 11))
+
+        view = table.view()
+        ports_to_update = [random.randint(0, 10) for i in range(5)]
+
+        def callback(port_id):
+            assert port_id in ports_to_update
+
+        view.on_update(callback)
+
+        for port in ports_to_update:
+            table.update(data, port_id=port)
+
+    def test_ports_multiple_tables_with_different_ports(self):
+        server = Table(data)
+        client = Table(data)
+
+        for i in range(random.randint(5, 15)):
+            # reserve an arbitary number of ports
+            server.make_port()
+
+        # port for client is now far above the ports "ON" the client, as the
+        # client ports will begin creation at 1.
+        server_port_for_client = server.make_port()
+        client_port = client.make_port()
+
+        server_view = server.view()
+        client_view = client.view()
+
+        # when the client updates, check whether the port id matches that
+        # of the server, and complete the test.
+        def client_callback(port_id, delta):
+            if port_id == client_port:
+                print("UPDATING SERVER")
+                server.update(delta, port_id=server_port_for_client)
+
+        # when the server updates, pass the update back to the client
+        def server_callback(port_id, delta):
+            print("UPDATING CLIENT")
+            assert port_id == server_port_for_client
+            assert server.size() == 8
+            server_view.delete()
+            server.delete()
+            client_view.delete()
+            client.delete()
+
+        client_view.on_update(client_callback, mode="row")
+        server_view.on_update(server_callback, mode="row")
+
+        client.update(data, port_id=client_port)

perspective/tests/table/test_remove.py

@@ -0,0 +1,102 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 perspective as psp
+
+client = psp.Server().new_local_client()
+Table = client.table
+
+
+class TestRemove(object):
+    def test_remove_all(self):
+        tbl = Table([{"a": "abc", "b": 123}], index="a")
+        tbl.remove(["abc"])
+        assert tbl.view().to_records() == []
+        # assert tbl.size() == 0
+
+    def test_remove_nonsequential(self):
+        tbl = Table(
+            [{"a": "abc", "b": 123}, {"a": "def", "b": 456}, {"a": "efg", "b": 789}],
+            index="a",
+        )
+        tbl.remove(["abc", "efg"])
+        assert tbl.view().to_records() == [{"a": "def", "b": 456}]
+        # assert tbl.size() == 1
+
+    def test_remove_multiple_single(self):
+        tbl = Table({"a": "integer", "b": "string"}, index="a")
+        for i in range(0, 10):
+            tbl.update([{"a": i, "b": str(i)}])
+        for i in range(1, 10):
+            tbl.remove([i])
+        assert tbl.view().to_records() == [{"a": 0, "b": "0"}]
+        # assert tbl.size() == 0
+
+    def test_remove_expressions(self):
+        schema = {"key": "string", "delta$": "float", "business_line": "string"}
+        data = [
+            {
+                "key": "A",
+                "delta$": 46412.3804275,
+            },
+            {
+                "key": "B",
+                "delta$": 2317615.875,
+            },
+        ]
+
+        table = Table(schema, index="key")
+        table.update(data)
+        table.remove(["A"])
+        view = table.view(
+            group_by=["business_line"],
+            columns=["delta$", "alias"],
+            expressions={
+                "alias": '"delta$"',
+            },
+        )
+
+        records = view.to_records()
+        assert records == [
+            {"__ROW_PATH__": [], "delta$": 2317615.875, "alias": 2317615.875},
+            {"__ROW_PATH__": [None], "delta$": 2317615.875, "alias": 2317615.875},
+        ]
+
+    def test_remove_expressions_after_view(self):
+        schema = {"key": "string", "delta$": "float", "business_line": "string"}
+        data = [
+            {
+                "key": "A",
+                "delta$": 46412.3804275,
+            },
+            {
+                "key": "B",
+                "delta$": 2317615.875,
+            },
+        ]
+
+        table = Table(schema, index="key")
+        table.update(data)
+        view = table.view(
+            group_by=["business_line"],
+            columns=["delta$", "alias"],
+            expressions={
+                "alias": '"delta$"',
+            },
+        )
+
+        table.remove(["A"])
+        records = view.to_records()
+        assert records == [
+            {"__ROW_PATH__": [], "delta$": 2317615.875, "alias": 2317615.875},
+            {"__ROW_PATH__": [None], "delta$": 2317615.875, "alias": 2317615.875},
+        ]