perspective-python 4.2.0__cp311-abi3-win_amd64.whl

perspective/tests/table/test_delete.py

@@ -0,0 +1,124 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 TestDelete(object):
+    # delete
+
+    def test_table_delete(self):
+        data = [{"a": 1, "b": 2}, {"a": 3, "b": 4}]
+        tbl = Table(data)
+        tbl.delete()
+        # don't segfault
+
+    def test_table_delete_callback(self, sentinel):
+        s = sentinel(False)
+
+        def callback():
+            s.set(True)
+
+        data = [{"a": 1, "b": 2}, {"a": 3, "b": 4}]
+        tbl = Table(data)
+        tbl.on_delete(callback)
+        tbl.delete()
+        assert s.get() is True
+
+    def test_table_delete_with_view(self, sentinel):
+        s = sentinel(False)
+
+        def callback():
+            s.set(True)
+
+        data = [{"a": 1, "b": 2}, {"a": 3, "b": 4}]
+        tbl = Table(data)
+        tbl.on_delete(callback)
+        view = tbl.view()
+        view.delete()
+        tbl.delete()
+        assert s.get() is True
+
+    def test_table_delete_multiple_callback(self, sentinel):
+        s1 = sentinel(False)
+        s2 = sentinel(False)
+
+        def callback1():
+            s1.set(True)
+
+        def callback2():
+            s2.set(True)
+
+        tbl = Table([{"a": 1}])
+        tbl.on_delete(callback1)
+        tbl.on_delete(callback2)
+
+        tbl.delete()
+
+        assert s1.get() is True
+        assert s2.get() is True
+
+    def test_table_remove_delete_callback(self, sentinel):
+        s = sentinel(False)
+
+        def callback():
+            s.set(True)
+
+        tbl = Table([{"a": 1}])
+        callback_id = tbl.on_delete(callback)
+        tbl.remove_delete(callback_id)
+
+        tbl.delete()
+
+        assert s.get() is False
+
+    def test_view_delete_multiple_callback(self, sentinel):
+        s1 = sentinel(False)
+        s2 = sentinel(False)
+
+        def callback1():
+            s1.set(True)
+
+        def callback2():
+            s2.set(True)
+
+        tbl = Table([{"a": 1}])
+        view = tbl.view()
+
+        view.on_delete(callback1)
+        view.on_delete(callback2)
+
+        view.delete()
+        tbl.delete()
+
+        assert s1.get() is True
+        assert s2.get() is True
+
+    def test_view_remove_delete_callback(self, sentinel):
+        s = sentinel(False)
+
+        def callback():
+            s.set(True)
+
+        tbl = Table([{"a": 1}])
+        view = tbl.view()
+
+        callback_id = view.on_delete(callback)
+        view.remove_delete(callback_id)
+
+        view.delete()
+        tbl.delete()
+
+        assert s.get() is False

perspective/tests/table/test_exception.py

@@ -0,0 +1,65 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 pytest import raises
+from perspective import PerspectiveError
+
+import perspective as psp
+
+client = psp.Server().new_local_client()
+Table = client.table
+
+
+class TestException(object):
+    def test_instantiation_exception_table(self):
+        from perspective import Table
+        with raises(TypeError) as ex:
+            Table()
+        assert "Do not call Table's constructor directly" in str(ex.value)
+
+    def test_instantiation_exception_view(self):
+        from perspective import View
+        with raises(TypeError) as ex:
+            View()
+        assert "Do not call View's constructor directly" in str(ex.value)
+
+    def test_exception_from_core(self):
+        tbl = Table({"a": [1, 2, 3]})
+
+        with raises(PerspectiveError) as ex:
+            # creating view with unknown column should throw
+            tbl.view(group_by=["b"])
+
+        assert str(ex.value) == "Abort(): Invalid column 'b' found in View group_by.\n"
+
+    def test_exception_from_core_catch_generic(self):
+        tbl = Table({"a": [1, 2, 3]})
+        # `PerspectiveCppError` should inherit from `Exception`
+        with raises(Exception) as ex:
+            tbl.view(group_by=["b"])
+
+        assert str(ex.value) == "Abort(): Invalid column 'b' found in View group_by.\n"
+
+    def test_exception_from_core_correct_types(self):
+        tbl = Table({"a": [1, 2, 3]})
+
+        # `PerspectiveError` should be raised from the Python layer
+        with raises(PerspectiveError) as ex:
+            tbl.view()
+            tbl.delete()
+
+        assert str(ex.value) == "Abort(): Cannot delete table with views"
+
+        with raises(PerspectiveError) as ex:
+            tbl.view(group_by=["b"])
+
+        assert str(ex.value) == "Abort(): Invalid column 'b' found in View group_by.\n"

perspective/tests/table/test_leaks.py

@@ -0,0 +1,54 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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 psutil
+import os
+import perspective as psp
+
+client = psp.Server().new_local_client()
+Table = client.table
+
+
+class TestDelete(object):
+    # delete
+
+    def test_table_delete(self):
+        process = psutil.Process(os.getpid())
+        data = [{"a": 1, "b": 2}, {"a": 3, "b": 4}]
+        tbl = Table(data)
+        tbl.delete()
+        mem = process.memory_info().rss
+
+        for x in range(10000):
+            data = [{"a": 1, "b": 2}, {"a": 3, "b": 4}]
+            tbl = Table(data)
+            tbl.delete()
+
+        mem2 = process.memory_info().rss
+
+        # assert 1 < (max2 / max) < 1.01
+        assert (mem2 - mem) < 2000000
+
+    def test_table_delete_with_view(self, sentinel):
+        data = [{"a": 1, "b": 2}, {"a": 3, "b": 4}]
+        tbl = Table(data)
+
+        process = psutil.Process(os.getpid())
+        mem = process.memory_info().rss
+        for x in range(10000):
+            view = tbl.view()
+            view.delete()
+
+        tbl.delete()
+        mem2 = process.memory_info().rss
+        assert (mem2 - mem) < 2000000

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},
+        ]