perspective-python 4.5.2__cp311-abi3-pyemscripten_2025_0_wasm32.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_join.py

@@ -0,0 +1,115 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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()
+
+
+class TestJoin:
+    def test_inner_join_two_tables(self):
+        left = client.table(
+            [{"id": 1, "x": 10}, {"id": 2, "x": 20}, {"id": 3, "x": 30}]
+        )
+        right = client.table(
+            [{"id": 1, "y": "a"}, {"id": 2, "y": "b"}, {"id": 4, "y": "d"}]
+        )
+        joined = client.join(left, right, "id")
+        view = joined.view()
+        json = view.to_json()
+        assert len(json) == 2
+        view.delete()
+        joined.delete()
+        right.delete()
+        left.delete()
+
+    def test_join_has_correct_schema(self):
+        left = client.table({"id": "integer", "x": "float"})
+        right = client.table({"id": "integer", "y": "string"})
+        joined = client.join(left, right, "id")
+        schema = joined.schema()
+        assert schema == {"id": "integer", "x": "float", "y": "string"}
+        joined.delete()
+        right.delete()
+        left.delete()
+
+    def test_join_reacts_to_left_updates(self):
+        left = client.table(
+            [{"id": 1, "x": 10}, {"id": 2, "x": 20}]
+        )
+        right = client.table(
+            [{"id": 1, "y": "a"}, {"id": 2, "y": "b"}]
+        )
+        joined = client.join(left, right, "id")
+        view = joined.view()
+        left.update([{"id": 1, "x": 99}])
+        json = view.to_json()
+        assert json == [
+            {"id": 1, "x": 10, "y": "a"},
+            {"id": 2, "x": 20, "y": "b"},
+            {"id": 1, "x": 99, "y": "a"},
+        ]
+        view.delete()
+        joined.delete()
+        right.delete()
+        left.delete()
+
+    def test_left_join(self):
+        left = client.table(
+            [{"id": 1, "x": 10}, {"id": 2, "x": 20}, {"id": 3, "x": 30}]
+        )
+        right = client.table(
+            [{"id": 1, "y": "a"}, {"id": 2, "y": "b"}]
+        )
+        joined = client.join(left, right, "id", "left")
+        view = joined.view()
+        json = view.to_json()
+        assert len(json) == 3
+        view.delete()
+        joined.delete()
+        right.delete()
+        left.delete()
+
+    def test_join_by_table_names(self):
+        left = client.table(
+            [{"id": 1, "x": 10}, {"id": 2, "x": 20}],
+            name="left_py",
+        )
+        right = client.table(
+            [{"id": 1, "y": "a"}, {"id": 2, "y": "b"}],
+            name="right_py",
+        )
+        joined = client.join("left_py", "right_py", "id")
+        view = joined.view()
+        json = view.to_json()
+        assert len(json) == 2
+        view.delete()
+        joined.delete()
+        right.delete()
+        left.delete()
+
+    def test_join_mixed_table_and_string(self):
+        left = client.table(
+            [{"id": 1, "x": 10}, {"id": 2, "x": 20}]
+        )
+        right = client.table(
+            [{"id": 1, "y": "a"}, {"id": 2, "y": "b"}],
+            name="right_py_mixed",
+        )
+        joined = client.join(left, "right_py_mixed", "id")
+        view = joined.view()
+        json = view.to_json()
+        assert len(json) == 2
+        view.delete()
+        joined.delete()
+        right.delete()
+        left.delete()

perspective/tests/table/test_leaks.py

@@ -0,0 +1,105 @@
+#  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+#  ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+#  ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+#  ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+#  ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+#  ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+#  ┃ 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
+
+
+class TestExpressionVocab(object):
+    # Regression tests for the `t_expression_vocab` leak fixed in PR #3175.
+    # Pre-fix, updates against a view with a string-producing expression
+    # interned each result into a new 4KB vocab page once the prior page
+    # filled, and never deduplicated against older pages. RSS grew without
+    # bound. The fix adds cross-page deduplication; these tests assert the
+    # steady state is flat.
+
+    def test_string_expression_update_no_leak(self):
+        long_literal = "X" * 256
+        tbl = Table({"x": "integer", "c": "string"}, index="x")
+        view = tbl.view(expressions={"e": 'concat("c", \'' + long_literal + "')"})
+
+        for _ in range(100):
+            tbl.update([{"x": 1, "c": "value"}])
+
+        process = psutil.Process(os.getpid())
+        mem = process.memory_info().rss
+        for _ in range(5000):
+            tbl.update([{"x": 1, "c": "value"}])
+        mem2 = process.memory_info().rss
+
+        view.delete()
+        tbl.delete()
+
+        assert (mem2 - mem) < 2000000
+
+    def test_string_expression_update_bounded_vocab_no_leak(self):
+        # Cycles through a small fixed set of distinct values. Exercises the
+        # cross-page `string_exists` lookup the fix relies on: once the
+        # vocabulary is fully populated, subsequent interns must resolve to
+        # existing pointers rather than allocating new ones.
+        values = ["alpha", "bravo", "charlie", "delta", "echo"]
+        tbl = Table({"x": "integer", "c": "string"}, index="x")
+        view = tbl.view(expressions={"e": 'upper("c")'})
+
+        for i in range(100):
+            tbl.update([{"x": 1, "c": values[i % len(values)]}])
+
+        process = psutil.Process(os.getpid())
+        mem = process.memory_info().rss
+        for i in range(5000):
+            tbl.update([{"x": 1, "c": values[i % len(values)]}])
+        mem2 = process.memory_info().rss
+
+        view.delete()
+        tbl.delete()
+
+        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)