pixeltable 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

pixeltable/tests/test_functions.py

@@ -1,11 +1,293 @@
-import sqlalchemy as sql
+from typing import Dict, Any
+
 import pytest
 
+import pixeltable as pxt
 from pixeltable import catalog
+from pixeltable.env import Env
 from pixeltable.functions.pil.image import blend
+from pixeltable.iterators import FrameIterator
+from pixeltable.tests.utils import get_video_files, skip_test_if_not_installed, get_sentences, get_image_files
+from pixeltable.type_system import VideoType, StringType, JsonType, ImageType, BoolType, FloatType, ArrayType
 
 
 class TestFunctions:
     def test_pil(self, img_tbl: catalog.Table) -> None:
         t = img_tbl
         _ = t[t.img, t.img.rotate(90), blend(t.img, t.img.rotate(90), 0.5)].show()
+
+    def test_eval_detections(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)
+
+        files = get_video_files()
+        video_t.insert(video=files[-1])
+        v.add_column(frame_s=v.frame.resize([640, 480]))
+        from pixeltable.functions.nos.object_detection_2d import yolox_nano, yolox_small, yolox_large
+        v.add_column(detections_a=yolox_nano(v.frame_s))
+        v.add_column(detections_b=yolox_small(v.frame_s))
+        v.add_column(gt=yolox_large(v.frame_s))
+        from pixeltable.functions.eval import eval_detections, mean_ap
+        res = v.select(
+            eval_detections(
+                v.detections_a.bboxes, v.detections_a.labels, v.detections_a.scores, v.gt.bboxes, v.gt.labels
+            )).show()
+        v.add_column(
+            eval_a=eval_detections(
+                v.detections_a.bboxes, v.detections_a.labels, v.detections_a.scores, v.gt.bboxes, v.gt.labels))
+        v.add_column(
+            eval_b=eval_detections(
+                v.detections_b.bboxes, v.detections_b.labels, v.detections_b.scores, v.gt.bboxes, v.gt.labels))
+        ap_a = v.select(mean_ap(v.eval_a)).show()[0, 0]
+        ap_b = v.select(mean_ap(v.eval_b)).show()[0, 0]
+        common_classes = set(ap_a.keys()) & set(ap_b.keys())
+
+        ## TODO: following assertion is failing on CI, 
+        # It is not necessarily a bug, as assert codition is not expected to be always true
+        # for k in common_classes:
+        # assert ap_a[k] <= ap_b[k]
+
+    def test_str(self, test_client: pxt.Client) -> None:
+        cl = test_client
+        t = cl.create_table('test_tbl', {'input': StringType()})
+        from pixeltable.functions.string import str_format
+        t.add_column(s1=str_format('ABC {0}', t.input))
+        t.add_column(s2=str_format('DEF {this}', this=t.input))
+        t.add_column(s3=str_format('GHI {0} JKL {this}', t.input, this=t.input))
+        status = t.insert(input='MNO')
+        assert status.num_rows == 1
+        assert status.num_excs == 0
+        row = t.head()[0]
+        assert row == {'input': 'MNO', 's1': 'ABC MNO', 's2': 'DEF MNO', 's3': 'GHI MNO JKL MNO'}
+
+    def test_openai(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('openai')
+        TestFunctions.skip_test_if_no_openai_client()
+        if Env.get().openai_client is None:
+            pytest.skip(f'OpenAI client does not exist (missing API key?).')
+        cl = test_client
+        t = cl.create_table('test_tbl', {'input': StringType()})
+        from pixeltable.functions.openai import chat_completions, embeddings, moderations
+        msgs = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": t.input}
+        ]
+        t.add_column(input_msgs=msgs)
+        t.add_column(chat_output=chat_completions(model='gpt-3.5-turbo', messages=t.input_msgs))
+        # with inlined messages
+        t.add_column(chat_output2=chat_completions(model='gpt-3.5-turbo', messages=msgs))
+        t.add_column(ada_embed=embeddings(model='text-embedding-ada-002', input=t.input))
+        t.add_column(text_3=embeddings(model='text-embedding-3-small', input=t.input))
+        t.add_column(moderation=moderations(input=t.input))
+        t.insert(input='I find you really annoying')
+        _ = t.head()
+
+    def test_gpt_4_vision(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('openai')
+        TestFunctions.skip_test_if_no_openai_client()
+        cl = test_client
+        t = cl.create_table('test_tbl', {'prompt': StringType(), 'img': ImageType()})
+        from pixeltable.functions.openai import chat_completions
+        from pixeltable.functions.string import str_format
+        msgs = [
+            {'role': 'user',
+             'content': [
+                 {'type': 'text', 'text': t.prompt},
+                 {'type': 'image_url', 'image_url': {
+                     'url': str_format('data:image/png;base64,{0}', t.img.b64_encode())
+                 }}
+             ]}
+        ]
+        t.add_column(response=chat_completions(model='gpt-4-vision-preview', messages=msgs, max_tokens=300))
+        t.add_column(response_content=t.response.choices[0].message.content)
+        t.insert(prompt="What's in this image?", img=_sample_image_url)
+        result = t.collect()['response_content'][0]
+        assert len(result) > 0
+
+    @staticmethod
+    def skip_test_if_no_openai_client() -> None:
+        if Env.get().openai_client is None:
+            pytest.skip(f'OpenAI client does not exist (missing API key?)')
+
+    def test_together(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('together')
+        if not Env.get().has_together_client:
+            pytest.skip(f'Together client does not exist (missing API key?)')
+        cl = test_client
+        t = cl.create_table('test_tbl', {'input': StringType()})
+        from pixeltable.functions.together import completions
+        t.add_column(output=completions(prompt=t.input, model='mistralai/Mixtral-8x7B-v0.1', stop=['\n']))
+        t.add_column(output_text=t.output.output.choices[0].text)
+        t.insert(input='I am going to the ')
+        result = t.select(t.output_text).collect()['output_text'][0]
+        assert len(result) > 0
+
+    def test_fireworks(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('fireworks')
+        try:
+            from pixeltable.functions.fireworks import initialize
+            initialize()
+        except:
+            pytest.skip(f'Fireworks client does not exist (missing API key?)')
+        cl = test_client
+        t = cl.create_table('test_tbl', {'input': StringType()})
+        from pixeltable.functions.fireworks import chat_completions
+        t['output'] = chat_completions(prompt=t.input, model='accounts/fireworks/models/llama-v2-7b-chat', max_tokens=256).choices[0].text
+        t.insert(input='I am going to the ')
+        result = t.select(t.output).collect()['output'][0]
+        assert len(result) > 0
+
+    def test_hf_function(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('sentence_transformers')
+        cl = test_client
+        t = cl.create_table('test_tbl', {'input': StringType(), 'bool_col': BoolType()})
+        from pixeltable.functions.huggingface import sentence_transformer
+        model_id = 'intfloat/e5-large-v2'
+        t.add_column(e5=sentence_transformer(t.input, model_id=model_id))
+        sents = get_sentences()
+        status = t.insert({'input': s, 'bool_col': True} for s in sents)
+        assert status.num_rows == len(sents)
+        assert status.num_excs == 0
+
+        # verify handling of constant params
+        with pytest.raises(ValueError) as exc_info:
+            t.add_column(e5_2=sentence_transformer(t.input, model_id=t.input))
+        assert ': parameter model_id must be a constant value' in str(exc_info.value)
+        with pytest.raises(ValueError) as exc_info:
+            t.add_column(e5_2=sentence_transformer(t.input, model_id=model_id, normalize_embeddings=t.bool_col))
+        assert ': parameter normalize_embeddings must be a constant value' in str(exc_info.value)
+
+        # make sure this doesn't cause an exception
+        # TODO: is there some way to capture the output?
+        t.describe()
+
+    def test_sentence_transformer(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('sentence_transformers')
+        cl = test_client
+        t = cl.create_table('test_tbl', {'input': StringType(), 'input_list': JsonType()})
+        sents = get_sentences(10)
+        status = t.insert({'input': s, 'input_list': sents} for s in sents)
+        assert status.num_rows == len(sents)
+        assert status.num_excs == 0
+
+        # run multiple models one at a time in order to exercise batching
+        from pixeltable.functions.huggingface import sentence_transformer, sentence_transformer_list
+        model_ids = ['sentence-transformers/all-mpnet-base-v2', 'BAAI/bge-reranker-base']
+        num_dims = [768, 768]
+        for idx, model_id in enumerate(model_ids):
+            col_name = f'embed{idx}'
+            t[col_name] = sentence_transformer(t.input, model_id=model_id, normalize_embeddings=True)
+            assert t.column_types()[col_name] == ArrayType((None,), dtype=FloatType(), nullable=False)
+            list_col_name = f'embed_list{idx}'
+            t[list_col_name] = sentence_transformer_list(t.input_list, model_id=model_id, normalize_embeddings=True)
+            assert t.column_types()[list_col_name] == JsonType()
+
+        def verify_row(row: Dict[str, Any]) -> None:
+            for idx, (_, d) in enumerate(zip(model_ids, num_dims)):
+                assert row[f'embed{idx}'].shape == (d,)
+                assert len(row[f'embed_list{idx}']) == len(sents)
+                assert all(len(v) == d for v in row[f'embed_list{idx}'])
+
+        verify_row(t.tail(1)[0])
+
+        # execution still works after reload
+        cl = pxt.Client(reload=True)
+        t = cl.get_table('test_tbl')
+        status = t.insert({'input': s, 'input_list': sents} for s in sents)
+        assert status.num_rows == len(sents)
+        assert status.num_excs == 0
+        verify_row(t.tail(1)[0])
+
+    def test_cross_encoder(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('sentence_transformers')
+        cl = test_client
+        t = cl.create_table('test_tbl', {'input': StringType(), 'input_list': JsonType()})
+        sents = get_sentences(10)
+        status = t.insert({'input': s, 'input_list': sents} for s in sents)
+        assert status.num_rows == len(sents)
+        assert status.num_excs == 0
+
+        # run multiple models one at a time in order to exercise batching
+        from pixeltable.functions.huggingface import cross_encoder, cross_encoder_list
+        model_ids = ['cross-encoder/ms-marco-MiniLM-L-6-v2', 'cross-encoder/ms-marco-TinyBERT-L-2-v2']
+        for idx, model_id in enumerate(model_ids):
+            col_name = f'embed{idx}'
+            t[col_name] = cross_encoder(t.input, t.input, model_id=model_id)
+            assert t.column_types()[col_name] == FloatType()
+            list_col_name = f'embed_list{idx}'
+            t[list_col_name] = cross_encoder_list(t.input, t.input_list, model_id=model_id)
+            assert t.column_types()[list_col_name] == JsonType()
+
+        def verify_row(row: Dict[str, Any]) -> None:
+            for i in range(len(model_ids)):
+                assert len(row[f'embed_list{idx}']) == len(sents)
+                assert all(isinstance(v, float) for v in row[f'embed_list{idx}'])
+
+        verify_row(t.tail(1)[0])
+
+        # execution still works after reload
+        cl = pxt.Client(reload=True)
+        t = cl.get_table('test_tbl')
+        status = t.insert({'input': s, 'input_list': sents} for s in sents)
+        assert status.num_rows == len(sents)
+        assert status.num_excs == 0
+        verify_row(t.tail(1)[0])
+
+    def test_clip(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('transformers')
+        cl = test_client
+        t = cl.create_table('test_tbl', {'text': StringType(), 'img': ImageType()})
+        num_rows = 10
+        sents = get_sentences(num_rows)
+        imgs = get_image_files()[:num_rows]
+        status = t.insert({'text': text, 'img': img} for text, img in zip(sents, imgs))
+        assert status.num_rows == len(sents)
+        assert status.num_excs == 0
+
+        # run multiple models one at a time in order to exercise batching
+        from pixeltable.functions.huggingface import clip_text, clip_image
+        model_ids = ['openai/clip-vit-base-patch32', 'laion/CLIP-ViT-B-32-laion2B-s34B-b79K']
+        for idx, model_id in enumerate(model_ids):
+            col_name = f'embed_text{idx}'
+            t[col_name] = clip_text(t.text, model_id=model_id)
+            assert t.column_types()[col_name] == ArrayType((None,), dtype=FloatType(), nullable=False)
+            col_name = f'embed_img{idx}'
+            t[col_name] = clip_image(t.img, model_id=model_id)
+            assert t.column_types()[col_name] == ArrayType((None,), dtype=FloatType(), nullable=False)
+
+        def verify_row(row: Dict[str, Any]) -> None:
+            for idx, _ in enumerate(model_ids):
+                assert row[f'embed_text{idx}'].shape == (512,)
+                assert row[f'embed_img{idx}'].shape == (512,)
+
+        verify_row(t.tail(1)[0])
+
+        # execution still works after reload
+        cl = pxt.Client(reload=True)
+        t = cl.get_table('test_tbl')
+        status = t.insert({'text': text, 'img': img} for text, img in zip(sents, imgs))
+        assert status.num_rows == len(sents)
+        assert status.num_excs == 0
+        verify_row(t.tail(1)[0])
+
+    def test_detr_for_object_detection(self, test_client: pxt.Client) -> None:
+        skip_test_if_not_installed('transformers')
+        cl = test_client
+        t = cl.create_table('test_tbl', {'img': ImageType()})
+        from pixeltable.functions.huggingface import detr_for_object_detection
+        t['detect'] = detr_for_object_detection(t.img, model_id='facebook/detr-resnet-50', threshold=0.8)
+        status = t.insert(img=_sample_image_url)
+        assert status.num_rows == 1
+        assert status.num_excs == 0
+        result = t.select(t.detect).collect()[0]['detect']
+        assert 'orange' in result['label_text']
+        assert 'bowl' in result['label_text']
+        assert 'broccoli' in result['label_text']
+
+
+_sample_image_url = \
+    'https://raw.githubusercontent.com/pixeltable/pixeltable/master/docs/source/data/images/000000000009.jpg'

pixeltable/tests/test_migration.py

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,208 @@
+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)