pixeltable 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

pixeltable/tests/test_function.py

@@ -1,324 +0,0 @@
-from typing import Optional
-
-import numpy as np
-import pytest
-
-import pixeltable as pxt
-import pixeltable.exceptions as excs
-from pixeltable import catalog
-from pixeltable.func import Function, FunctionRegistry, Batch
-from pixeltable.type_system import IntType, FloatType
-from pixeltable.tests.utils import assert_resultset_eq
-import pixeltable.func as func
-
-
-def dummy_fn(i: int) -> int:
-    return i
-
-class TestFunction:
-    @pxt.udf(return_type=IntType(), param_types=[IntType()])
-    def func(x: int) -> int:
-        return x + 1
-
-    @pxt.uda(name='agg', value_type=IntType(), update_types=[IntType()])
-    class Aggregator:
-        def __init__(self):
-            self.sum = 0
-        def update(self, val: int) -> None:
-            if val is not None:
-                self.sum += val
-        def value(self) -> int:
-            return self.sum
-
-    def test_serialize_anonymous(self, init_env) -> None:
-        d = self.func.as_dict()
-        FunctionRegistry.get().clear_cache()
-        deserialized = Function.from_dict(d)
-        # TODO: add Function.exec() and then use that
-        assert deserialized.py_fn(1) == 2
-
-    @pytest.mark.skip(reason='deprecated')
-    def test_create(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        cl.create_function('test_fn', self.func)
-        assert self.func.md.fqn == 'test_fn'
-        FunctionRegistry.get().clear_cache()
-        cl = pxt.Client(reload=True)
-        _ = cl.list_functions()
-        fn2 = cl.get_function('test_fn')
-        assert fn2.md.fqn == 'test_fn'
-        assert fn2.py_fn(1) == 2
-
-        with pytest.raises(excs.Error):
-            cl.create_function('test_fn', self.func)
-        with pytest.raises(excs.Error):
-            cl.create_function('dir1.test_fn', self.func)
-        with pytest.raises(excs.Error):
-            library_fn = make_library_function(IntType(), [IntType()], __name__, 'dummy_fn')
-            cl.create_function('library_fn', library_fn)
-
-    @pytest.mark.skip(reason='deprecated')
-    def test_update(self, test_client: pxt.Client, test_tbl: catalog.Table) -> None:
-        cl = test_client
-        t = test_tbl
-        cl.create_function('test_fn', self.func)
-        res1 = t[self.func(t.c2)].show(0).to_pandas()
-
-        # load function from db and make sure it computes the same thing as before
-        FunctionRegistry.get().clear_cache()
-        cl = pxt.Client(reload=True)
-        fn = cl.get_function('test_fn')
-        res2 = t[fn(t.c2)].show(0).to_pandas()
-        assert res1.col_0.equals(res2.col_0)
-        fn.py_fn = lambda x: x + 2
-        cl.update_function('test_fn', fn)
-        assert self.func.md.fqn == fn.md.fqn  # fqn doesn't change
-
-        FunctionRegistry.get().clear_cache()
-        cl = pxt.Client(reload=True)
-        fn = cl.get_function('test_fn')
-        assert self.func.md.fqn == fn.md.fqn  # fqn doesn't change
-        res3 = t[fn(t.c2)].show(0).to_pandas()
-        assert (res2.col_0 + 1).equals(res3.col_0)
-
-        # signature changes
-        with pytest.raises(excs.Error):
-            cl.update_function('test_fn', make_function(FloatType(), [IntType()], fn.py_fn))
-        with pytest.raises(excs.Error):
-            cl.update_function('test_fn', make_function(IntType(), [FloatType()], fn.py_fn))
-        with pytest.raises(excs.Error):
-            cl.update_function('test_fn', self.agg)
-
-    @pytest.mark.skip(reason='deprecated')
-    def test_move(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        cl.create_function('test_fn', self.func)
-
-        FunctionRegistry.get().clear_cache()
-        cl = pxt.Client(reload=True)
-        with pytest.raises(excs.Error):
-            cl.move('test_fn2', 'test_fn')
-        cl.move('test_fn', 'test_fn2')
-        func = cl.get_function('test_fn2')
-        assert func.py_fn(1) == 2
-        assert func.md.fqn == 'test_fn2'
-
-        with pytest.raises(excs.Error):
-            _ = cl.get_function('test_fn')
-
-        # move function between directories
-        cl.create_dir('functions')
-        cl.create_dir('functions2')
-        cl.create_function('functions.func1', self.func)
-        with pytest.raises(excs.Error):
-            cl.move('functions2.func1', 'functions.func1')
-        cl.move('functions.func1', 'functions2.func1')
-        func = cl.get_function('functions2.func1')
-        assert func.md.fqn == 'functions2.func1'
-
-
-        FunctionRegistry.get().clear_cache()
-        cl = pxt.Client(reload=True)
-        func = cl.get_function('functions2.func1')
-        assert func.py_fn(1) == 2
-        assert func.md.fqn == 'functions2.func1'
-        with pytest.raises(excs.Error):
-            _ = cl.get_function('functions.func1')
-
-    @pytest.mark.skip(reason='deprecated')
-    def test_drop(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        cl.create_function('test_fn', self.func)
-        FunctionRegistry.get().clear_cache()
-        cl = pxt.Client(reload=True)
-        cl.drop_function('test_fn')
-
-        with pytest.raises(excs.Error):
-            _ = cl.get_function('test_fn')
-
-    def test_list(self, test_client: pxt.Client) -> None:
-        _ = FunctionRegistry.get().list_functions()
-        print(_)
-
-    def test_stored_udf(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        t = cl.create_table('test', {'c1': pxt.IntType(), 'c2': pxt.FloatType()})
-        rows = [{'c1': i, 'c2': i + 0.5} for i in range(100)]
-        status = t.insert(rows)
-        assert status.num_rows == len(rows)
-        assert status.num_excs == 0
-
-        @pxt.udf(_force_stored=True)
-        def f1(a: int, b: float) -> float:
-            return a + b
-        t['f1'] = f1(t.c1, t.c2)
-
-        func.FunctionRegistry.get().clear_cache()
-        cl = pxt.Client(reload=True)
-        t = cl.get_table('test')
-        status = t.insert(rows)
-        assert status.num_rows == len(rows)
-        assert status.num_excs == 0
-
-    def test_call(self, test_tbl: catalog.Table) -> None:
-        t = test_tbl
-
-        @pxt.udf(return_type=IntType(), param_types=[IntType(), FloatType(), FloatType(), FloatType()])
-        def f1(a: int, b: float, c: float = 0.0, d: float = 1.0) -> float:
-            return a + b + c + d
-
-        r0 = t[t.c2, t.c3].show(0).to_pandas()
-        # positional params with default args
-        r1 = t[f1(t.c2, t.c3)].show(0).to_pandas()['col_0']
-        assert np.all(r1 == r0.c2 + r0.c3 + 1.0)
-        # kw args only
-        r2 = t[f1(c=0.0, b=t.c3, a=t.c2)].show(0).to_pandas()['col_0']
-        assert np.all(r1 == r2)
-        # overriding default args
-        r3 = t[f1(d=0.0, c=1.0, b=t.c3, a=t.c2)].show(0).to_pandas()['col_0']
-        assert np.all(r2 == r3)
-        # overriding default with positional arg
-        r4 = t[f1(t.c2, t.c3, 0.0)].show(0).to_pandas()['col_0']
-        assert np.all(r3 == r4)
-        # overriding default with positional arg and kw arg
-        r5 = t[f1(t.c2, t.c3, 1.0, d=0.0)].show(0).to_pandas()['col_0']
-        assert np.all(r4 == r5)
-        # d is kwarg
-        r6 = t[f1(t.c2, d=1.0, b=t.c3)].show(0).to_pandas()['col_0']
-        assert np.all(r5 == r6)
-        # d is Expr kwarg
-        r6 = t[f1(1, d=t.c3, b=t.c3)].show(0).to_pandas()['col_0']
-        assert np.all(r5 == r6)
-
-        # test handling of Nones
-        @pxt.udf(
-            return_type=IntType(),
-            param_types=[IntType(nullable=True), FloatType(nullable=False), FloatType(nullable=True)])
-        def f2(a: int, b: float = 0.0, c: float = 1.0) -> float:
-            return (0.0 if a is None else a) + b + (0.0 if c is None else c)
-        r0 = t[f2(1, t.c3)].show(0).to_pandas()['col_0']
-        r1 = t[f2(None, t.c3, 2.0)].show(0).to_pandas()['col_0']
-        assert np.all(r0 == r1)
-        r2 = t[f2(2, t.c3, None)].show(0).to_pandas()['col_0']
-        assert np.all(r1 == r2)
-        # kwarg with None
-        r3 = t[f2(c=None, a=t.c2)].show(0).to_pandas()['col_0']
-        # kwarg with Expr
-        r4 = t[f2(c=t.c3, a=None)].show(0).to_pandas()['col_0']
-        assert np.all(r3 == r4)
-
-        with pytest.raises(TypeError) as exc_info:
-            _ = t[f1(t.c2, c=0.0)].show(0)
-        assert "'b'" in str(exc_info.value)
-        with pytest.raises(TypeError) as exc_info:
-            _ = t[f1(t.c2)].show(0)
-        assert "'b'" in str(exc_info.value)
-        with pytest.raises(TypeError) as exc_info:
-            _ = t[f1(c=1.0, a=t.c2)].show(0)
-        assert "'b'" in str(exc_info.value)
-
-        # bad default value
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf(return_type=IntType(), param_types=[IntType(), FloatType(), FloatType()])
-            def f1(a: int, b: float, c: str = '') -> float:
-                return a + b + c
-        assert 'default value' in str(exc_info.value).lower()
-        # missing param type
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf(return_type=IntType(), param_types=[IntType(), FloatType()])
-            def f1(a: int, b: float, c: str = '') -> float:
-                return a + b + c
-        assert 'missing type for parameter c' in str(exc_info.value).lower()
-        # bad parameter name
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf(return_type=IntType(), param_types=[IntType()])
-            def f1(group_by: int) -> int:
-                return group_by
-        assert 'reserved' in str(exc_info.value)
-        # bad parameter name
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf(return_type=IntType(), param_types=[IntType()])
-            def f1(order_by: int) -> int:
-                return order_by
-        assert 'reserved' in str(exc_info.value)
-
-    def test_expr_udf(self, test_tbl: catalog.Table) -> None:
-        t = test_tbl
-        @pxt.expr_udf
-        def times2(x: int) -> int:
-            return x + x
-        res1 = t.select(out=times2(t.c2)).order_by(t.c2).collect()
-        res2 = t.select(t.c2 * 2).order_by(t.c2).collect()
-        assert_resultset_eq(res1, res2)
-
-        with pytest.raises(TypeError) as exc_info:
-            _ = t.select(times2(y=t.c2)).collect()
-        assert 'missing a required argument' in str(exc_info.value).lower()
-
-        with pytest.raises(excs.Error) as exc_info:
-            # parameter types cannot be inferred
-            @pxt.expr_udf
-            def add1(x, y) -> int:
-                return x + y
-        assert 'cannot infer pixeltable type' in str(exc_info.value).lower()
-
-        with pytest.raises(excs.Error) as exc_info:
-            # return type cannot be inferred
-            @pxt.expr_udf
-            def add1(x: int, y: int):
-                return x + y
-        assert 'cannot infer pixeltable return type' in str(exc_info.value).lower()
-
-        with pytest.raises(excs.Error) as exc_info:
-            # missing param types
-            @pxt.expr_udf(param_types=[IntType()])
-            def add1(x, y) -> int:
-                return x + y
-        assert 'missing type for parameter y' in str(exc_info.value).lower()
-
-        with pytest.raises(TypeError) as exc_info:
-            # signature has correct parameter kind
-            @pxt.expr_udf
-            def add1(*, x: int) -> int:
-                return x + 1
-            _ = t.select(add1(t.c2)).collect()
-        assert 'takes 0 positional arguments' in str(exc_info.value).lower()
-
-        @pxt.expr_udf
-        def add2(x: int, y: int = 1) -> int:
-            return x + y
-        res1 = t.select(out=add2(t.c2)).order_by(t.c2).collect()
-
-    # Test that various invalid udf definitions generate
-    # correct error messages.
-    def test_invalid_udfs(self):
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf
-            def udf1(name: Batch[str]) -> str:
-                return ''
-        assert 'batched parameters in udf, but no `batch_size` given' in str(exc_info.value).lower()
-
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf(batch_size=32)
-            def udf2(name: Batch[str]) -> str:
-                return ''
-        assert 'batch_size is specified; Python return type must be a `Batch`' in str(exc_info.value)
-
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf
-            def udf3(name: str) -> Optional[np.ndarray]:
-                return None
-        assert 'cannot infer pixeltable return type' in str(exc_info.value).lower()
-
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf
-            def udf4(array: np.ndarray) -> str:
-                return ''
-        assert 'cannot infer pixeltable type for parameter array' in str(exc_info.value).lower()
-
-        with pytest.raises(excs.Error) as exc_info:
-            @pxt.udf
-            def udf5(name: str, untyped) -> str:
-                return ''
-        assert 'cannot infer pixeltable type for parameter untyped' in str(exc_info.value).lower()
-

pixeltable/tests/test_migration.py

@@ -1,43 +0,0 @@
-import glob
-import logging
-import os
-import subprocess
-
-import pgserver
-import pytest
-
-import pixeltable as pxt
-from pixeltable.env import Env
-from pixeltable.tests.conftest import clean_db
-
-_logger = logging.getLogger('pixeltable')
-
-
-class TestMigration:
-
-    @pytest.mark.skip(reason='Suspended')
-    def test_db_migration(self, init_env) -> None:
-        env = Env.get()
-        pg_package_dir = os.path.dirname(pgserver.__file__)
-        pg_restore_binary = f'{pg_package_dir}/pginstall/bin/pg_restore'
-        _logger.info(f'Using pg_restore binary at: {pg_restore_binary}')
-        dump_files = glob.glob('pixeltable/tests/data/dbdumps/*.dump.gz')
-        dump_files.sort()
-        for dump_file in dump_files:
-            _logger.info(f'Testing migration from DB dump {dump_file}.')
-            _logger.info(f'DB URL: {env.db_url}')
-            clean_db(restore_tables=False)
-            with open(dump_file, 'rb') as dump:
-                gunzip_process = subprocess.Popen(
-                    ["gunzip", "-c"],
-                    stdin=dump,
-                    stdout=subprocess.PIPE
-                )
-                subprocess.run(
-                    [pg_restore_binary, '-d', env.db_url, '-U', 'postgres'],
-                    stdin=gunzip_process.stdout,
-                    check=True
-                )
-            # TODO(aaron-siegel) This will test that the migration succeeds without raising any exceptions.
-            # We should also add some assertions to sanity-check the outcome.
-            _ = pxt.Client()

pixeltable/tests/test_nos.py

@@ -1,54 +0,0 @@
-import pytest
-
-import pixeltable as pxt
-from pixeltable.iterators import FrameIterator
-from pixeltable.tests.utils import get_video_files, skip_test_if_not_installed
-from pixeltable.type_system import ImageType, VideoType
-
-
-class TestNOS:
-    def test_basic(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('nos')
-        cl = test_client
-        video_t = cl.create_table('video_tbl', {'video': VideoType()})
-        # create frame view
-        args = {'video': video_t.video, 'fps': 1}
-        v = cl.create_view('test_view', video_t, iterator_class=FrameIterator, iterator_args=args)
-        v.add_column(transform1=v.frame.rotate(30), stored=False)
-        from pixeltable.functions.nos.object_detection_2d import \
-            torchvision_fasterrcnn_mobilenet_v3_large_320_fpn as fasterrcnn
-        v.add_column(detections=fasterrcnn(v.transform1))
-        from pixeltable.functions.nos.image_embedding import openai_clip
-        v.add_column(embed=openai_clip(v.transform1.resize([224, 224])))
-        # add a stored column that isn't referenced in nos calls
-        v.add_column(transform2=v.frame.rotate(60), stored=True)
-
-        status = video_t.insert(video=get_video_files()[0])
-        pass
-
-    def test_exceptions(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('nos')
-        cl = test_client
-        video_t = cl.create_table('video_tbl', {'video': VideoType()})
-        # create frame view
-        args = {'video': video_t.video, 'fps': 1}
-        v = cl.create_view('test_view', video_t, iterator_class=FrameIterator, iterator_args=args)
-        video_t.insert(video=get_video_files()[0])
-
-        v.add_column(frame_s=v.frame.resize([640, 480]))
-        # 'rotated' has exceptions
-        v.add_column(rotated=lambda frame_s, frame_idx: frame_s.rotate(int(360 / frame_idx)), type=ImageType())
-        from pixeltable.functions.nos.object_detection_2d import yolox_medium
-        v.add_column(detections=yolox_medium(v.rotated), stored=True)
-        assert v.where(v.detections.errortype != None).count() == 1
-
-    @pytest.mark.skip(reason='too slow')
-    def test_sd(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('nos')
-        """Test model that mixes batched with scalar parameters"""
-        t = test_client.create_table('sd_test', {'prompt': pxt.StringType()})
-        t.insert(prompt='cat on a sofa')
-        from pixeltable.functions.nos.image_generation import stabilityai_stable_diffusion_2 as sd2
-        t.add_column(img=sd2(t.prompt, 1, 512, 512), stored=True)
-        img = t[t.img].show(1)[0, 0]
-        assert img.size == (512, 512)

pixeltable/tests/test_snapshot.py

@@ -1,208 +0,0 @@
-from typing import Any, Dict
-
-import numpy as np
-import pytest
-
-import pixeltable as pxt
-import pixeltable.exceptions as excs
-from pixeltable.tests.utils import create_test_tbl, assert_resultset_eq
-from pixeltable.type_system import IntType
-
-
-class TestSnapshot:
-    def run_basic_test(
-            self, cl: pxt.Client, tbl: pxt.Table, snap: pxt.Table, extra_items: Dict[str, Any], filter: Any,
-            reload_md: bool
-    ) -> None:
-        tbl_path, snap_path = cl.get_path(tbl), cl.get_path(snap)
-        # run the initial query against the base table here, before reloading, otherwise the filter breaks
-        tbl_select_list = [tbl[col_name] for col_name in tbl.column_names()]
-        tbl_select_list.extend([value_expr for _, value_expr in extra_items.items()])
-        orig_resultset = tbl.select(*tbl_select_list).where(filter).order_by(tbl.c2).collect()
-
-        if reload_md:
-            # reload md
-            cl = pxt.Client(reload=True)
-            tbl = cl.get_table(tbl_path)
-            snap = cl.get_table(snap_path)
-
-        # view select list: base cols followed by view cols
-        snap_select_list = [snap[col_name] for col_name in snap.column_names()[len(extra_items):]]
-        snap_select_list.extend([snap[col_name] for col_name in extra_items.keys()])
-        snap_query = snap.select(*snap_select_list).order_by(snap.c2)
-        r1 = list(orig_resultset)
-        r2 = list(snap_query.collect())
-        assert_resultset_eq(snap_query.collect(), orig_resultset)
-
-        # adding data to a base table doesn't change the snapshot
-        rows = list(tbl.select(tbl.c1, tbl.c1n, tbl.c2, tbl.c3, tbl.c4, tbl.c5, tbl.c6, tbl.c7).collect())
-        status = tbl.insert(rows)
-        assert status.num_rows == len(rows)
-        assert_resultset_eq(snap_query.collect(), orig_resultset)
-
-        # update() doesn't affect the view
-        status = tbl.update({'c3': tbl.c3 + 1.0})
-        assert status.num_rows == tbl.count()
-        assert_resultset_eq(snap_query.collect(), orig_resultset)
-
-        # delete() doesn't affect the view
-        num_tbl_rows = tbl.count()
-        status = tbl.delete()
-        assert status.num_rows == num_tbl_rows
-        assert_resultset_eq(snap_query.collect(), orig_resultset)
-
-        tbl.revert()  # undo delete()
-        tbl.revert()  # undo update()
-        tbl.revert()  # undo insert()
-        # can't revert a version referenced by a snapshot
-        with pytest.raises(excs.Error) as excinfo:
-            tbl.revert()
-        assert 'version is needed' in str(excinfo.value)
-
-        # can't drop a table with snapshots
-        with pytest.raises(excs.Error) as excinfo:
-            cl.drop_table(tbl_path)
-        assert snap_path in str(excinfo.value)
-
-        cl.drop_table(snap_path)
-        cl.drop_table(tbl_path)
-
-    def test_basic(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        cl.create_dir('main')
-        cl.create_dir('snap')
-        tbl_path = 'main.tbl1'
-        snap_path = 'snap.snap1'
-
-        for reload_md in [False, True]:
-            for has_filter in [False, True]:
-                for has_cols in [False, True]:
-                    cl = pxt.Client(reload=True)
-                    tbl = create_test_tbl(name=tbl_path, client=cl)
-                    schema = {
-                        'v1': tbl.c3 * 2.0,
-                        # include a lambda to make sure that is handled correctly
-                        'v2': {'value': lambda c3: c3 * 2.0, 'type': pxt.FloatType()}
-                    } if has_cols else {}
-                    extra_items = {'v1': tbl.c3 * 2.0, 'v2': tbl.c3 * 2.0} if has_cols else {}
-                    filter = tbl.c2 < 10 if has_filter else None
-                    snap = cl.create_view(snap_path, tbl, schema=schema, filter=filter, is_snapshot=True)
-                    self.run_basic_test(cl, tbl, snap, extra_items=extra_items, filter=filter, reload_md=reload_md)
-
-    def test_views_of_snapshots(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        t = cl.create_table('tbl', {'a': IntType()})
-        rows = [{'a': 1}, {'a': 2}, {'a': 3}]
-        status = t.insert(rows)
-        assert status.num_rows == len(rows)
-        assert status.num_excs == 0
-        s1 = cl.create_view('s1', t, is_snapshot=True)
-        v1 = cl.create_view('v1', s1, is_snapshot=False)
-        s2 = cl.create_view('s2', v1, is_snapshot=True)
-        v2 = cl.create_view('v2', s2, is_snapshot=False)
-
-        def verify(s1: pxt.Table, s2: pxt.Table, v1: pxt.Table, v2: pxt.Table) -> None:
-            assert s1.count() == len(rows)
-            assert v1.count() == len(rows)
-            assert s2.count() == len(rows)
-            assert v2.count() == len(rows)
-
-        verify(s1, s2, v1, v2)
-
-        status = t.insert(rows)
-        assert status.num_rows == len(rows)
-        assert status.num_excs == 0
-        verify(s1, s2, v1, v2)
-
-        cl = pxt.Client(reload=True)
-        s1 = cl.get_table('s1')
-        s2 = cl.get_table('s2')
-        v1 = cl.get_table('v1')
-        v2 = cl.get_table('v2')
-        verify(s1, s2, v1, v2)
-
-    def test_snapshot_of_view_chain(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        t = cl.create_table('tbl', {'a': IntType()})
-        rows = [{'a': 1}, {'a': 2}, {'a': 3}]
-        status = t.insert(rows)
-        assert status.num_rows == len(rows)
-        assert status.num_excs == 0
-        v1 = cl.create_view('v1', t, is_snapshot=False)
-        v2 = cl.create_view('v2', v1, is_snapshot=False)
-        s = cl.create_view('s', v2, is_snapshot=True)
-
-        def verify(v1: pxt.Table, v2: pxt.Table, s: pxt.Table) -> None:
-            assert v1.count() == t.count()
-            assert v2.count() == t.count()
-            assert s.count() == len(rows)
-
-        verify(v1, v2, s)
-
-        status = t.insert(rows)
-        assert status.num_rows == len(rows) * 3  # we also updated 2 views
-        assert status.num_excs == 0
-        verify(v1, v2, s)
-
-        cl = pxt.Client(reload=True)
-        v1 = cl.get_table('v1')
-        v2 = cl.get_table('v2')
-        s = cl.get_table('s')
-        verify(v1, v2, s)
-
-    def test_multiple_snapshot_paths(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        t = create_test_tbl(cl)
-        c4 = t.select(t.c4).order_by(t.c2).collect().to_pandas()['c4']
-        orig_c3 = t.select(t.c3).collect().to_pandas()['c3']
-        v = cl.create_view('v', base=t, schema={'v1': t.c3 + 1})
-        s1 = cl.create_view('s1', v, is_snapshot=True)
-        t.drop_column('c4')
-        # s2 references the same view version as s1, but a different version of t (due to a schema change)
-        s2 = cl.create_view('s2', v, is_snapshot=True)
-        t.update({'c6': {'a': 17}})
-        # s3 references the same view version as s2, but a different version of t (due to a data change)
-        s3 = cl.create_view('s3', v, is_snapshot=True)
-        t.update({'c3': t.c3 + 1})
-        # s4 references different versions of t and v
-        s4 = cl.create_view('s4', v, is_snapshot=True)
-
-        def validate(t: pxt.Table, v: pxt.Table, s1: pxt.Table, s2: pxt.Table, s3: pxt.Table, s4: pxt.Table) -> None:
-            # c4 is only visible in s1
-            assert np.all(s1.select(s1.c4).collect().to_pandas()['c4'] == c4)
-            with pytest.raises(AttributeError):
-                _ = t.select(t.c4).collect()
-            with pytest.raises(AttributeError):
-                _ = v.select(v.c4).collect()
-            with pytest.raises(AttributeError):
-                _ = s2.select(s2.c4).collect()
-            with pytest.raises(AttributeError):
-                _ = s3.select(s3.c4).collect()
-            with pytest.raises(AttributeError):
-                _ = s4.select(s4.c4).collect()
-
-            # c3
-            assert np.all(t.select(t.c3).order_by(t.c2).collect().to_pandas()['c3'] == orig_c3 + 1)
-            assert np.all(s1.select(s1.c3).order_by(s1.c2).collect().to_pandas()['c3'] == orig_c3)
-            assert np.all(s2.select(s2.c3).order_by(s2.c2).collect().to_pandas()['c3'] == orig_c3)
-            assert np.all(s3.select(s3.c3).order_by(s3.c2).collect().to_pandas()['c3'] == orig_c3)
-            assert np.all(s4.select(s4.c3).order_by(s4.c2).collect().to_pandas()['c3'] == orig_c3 + 1)
-
-            # v1
-            assert np.all(
-                v.select(v.v1).order_by(v.c2).collect().to_pandas()['v1'] == \
-                t.select(t.c3).order_by(t.c2).collect().to_pandas()['c3'] + 1)
-            assert np.all(s1.select(s1.v1).order_by(s1.c2).collect().to_pandas()['v1'] == orig_c3 + 1)
-            assert np.all(s2.select(s2.v1).order_by(s2.c2).collect().to_pandas()['v1'] == orig_c3 + 1)
-            assert np.all(s3.select(s3.v1).order_by(s3.c2).collect().to_pandas()['v1'] == orig_c3 + 1)
-            assert np.all(
-                s4.select(s4.v1).order_by(s4.c2).collect().to_pandas()['v1'] == \
-                t.select(t.c3).order_by(t.c2).collect().to_pandas()['c3'] + 1)
-
-        validate(t, v, s1, s2, s3, s4)
-
-        # make sure it works after metadata reload
-        cl = pxt.Client(reload=True)
-        t, v = cl.get_table('test_tbl'), cl.get_table('v')
-        s1, s2, s3, s4 = cl.get_table('s1'), cl.get_table('s2'), cl.get_table('s3'), cl.get_table('s4')
-        validate(t, v, s1, s2, s3, s4)