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

pixeltable/tests/test_exprs.py

@@ -22,6 +22,48 @@ from pixeltable.type_system import StringType, BoolType, IntType, ArrayType, Col
 
 
 class TestExprs:
+    @pxt.udf(return_type=FloatType(), param_types=[IntType(), IntType()])
+    def div_0_error(a: int, b: int) -> float:
+        return a / b
+
+    # function that does allow nulls
+    @pxt.udf(return_type=FloatType(nullable=True),
+            param_types=[FloatType(nullable=False), FloatType(nullable=True)])
+    def null_args_fn(a: int, b: int) -> int:
+        if b is None:
+            return a
+        return a + b
+
+    # error in agg.init()
+    @pxt.uda(update_types=[IntType()], value_type=IntType())
+    class init_exc(pxt.Aggregator):
+        def __init__(self):
+            self.sum = 1 / 0
+        def update(self, val):
+            pass
+        def value(self):
+            return 1
+
+    # error in agg.update()
+    @pxt.uda(update_types=[IntType()], value_type=IntType())
+    class update_exc(pxt.Aggregator):
+        def __init__(self):
+            self.sum = 0
+        def update(self, val):
+            self.sum += 1 / val
+        def value(self):
+            return 1
+
+    # error in agg.value()
+    @pxt.uda(update_types=[IntType()], value_type=IntType())
+    class value_exc(pxt.Aggregator):
+        def __init__(self):
+            self.sum = 0
+        def update(self, val):
+            self.sum += val
+        def value(self):
+            return 1 / self.sum
+
     def test_basic(self, test_tbl: catalog.Table) -> None:
         t = test_tbl
         assert t['c1'].equals(t.c1)
@@ -62,13 +104,13 @@ class TestExprs:
             _ = t.where((t.c1 == 'test string') or (t.c6.f1 > 50)).collect()
         assert 'cannot be used in conjunction with python boolean operators' in str(exc_info.value).lower()
 
-        # compound predicates with Python functions
-        @pxt.udf(return_type=BoolType(), param_types=[StringType()])
-        def udf(_: str) -> bool:
-            return True
-        @pxt.udf(return_type=BoolType(), param_types=[IntType()])
-        def udf2(_: int) -> bool:
-            return True
+        # # compound predicates with Python functions
+        # @pt.udf(return_type=BoolType(), param_types=[StringType()])
+        # def udf(_: str) -> bool:
+        #     return True
+        # @pt.udf(return_type=BoolType(), param_types=[IntType()])
+        # def udf2(_: int) -> bool:
+        #     return True
 
         # TODO: find a way to test this
         # # & can be split
@@ -120,47 +162,21 @@ class TestExprs:
             _ = t[(t.c6.f2 + 1) / (t.c2 - 10)].show()
 
         # the same, but with an inline function
-        @pxt.udf(return_type=FloatType(), param_types=[IntType(), IntType()])
-        def f(a: int, b: int) -> float:
-            return a / b
         with pytest.raises(excs.Error):
-            _ = t[f(t.c2 + 1, t.c2)].show()
+            _ = t[self.div_0_error(t.c2 + 1, t.c2)].show()
 
         # error in agg.init()
-        @pxt.uda(update_types=[IntType()], value_type=IntType(), name='agg')
-        class Aggregator(pxt.Aggregator):
-            def __init__(self):
-                self.sum = 1 / 0
-            def update(self, val):
-                pass
-            def value(self):
-                return 1
-        with pytest.raises(excs.Error):
-            _ = t[agg(t.c2)].show()
+        with pytest.raises(excs.Error) as exc_info:
+            _ = t[self.init_exc(t.c2)].show()
+        assert 'division by zero' in str(exc_info.value)
 
         # error in agg.update()
-        @pxt.uda(update_types=[IntType()], value_type=IntType(), name='agg')
-        class Aggregator(pxt.Aggregator):
-            def __init__(self):
-                self.sum = 0
-            def update(self, val):
-                self.sum += 1 / val
-            def value(self):
-                return 1
         with pytest.raises(excs.Error):
-            _ = t[agg(t.c2 - 10)].show()
+            _ = t[self.update_exc(t.c2 - 10)].show()
 
         # error in agg.value()
-        @pxt.uda(update_types=[IntType()], value_type=IntType(), name='agg')
-        class Aggregator(pxt.Aggregator):
-            def __init__(self):
-                self.sum = 0
-            def update(self, val):
-                self.sum += val
-            def value(self):
-                return 1 / self.sum
         with pytest.raises(excs.Error):
-            _ = t[t.c2 <= 2][agg(t.c2 - 1)].show()
+            _ = t[t.c2 <= 2][self.value_exc(t.c2 - 1)].show()
 
     def test_props(self, test_tbl: catalog.Table, img_tbl: catalog.Table) -> None:
         t = test_tbl
@@ -221,14 +237,7 @@ class TestExprs:
 
         # computed column that doesn't allow nulls
         t.add_column(c3=lambda c1, c2: c1 + c2, type=FloatType(nullable=False))
-        # function that does allow nulls
-        @pxt.udf(return_type=FloatType(nullable=True),
-                 param_types=[FloatType(nullable=False), FloatType(nullable=True)])
-        def f(a: int, b: int) -> int:
-            if b is None:
-                return a
-            return a + b
-        t.add_column(c4=f(t.c1, t.c2))
+        t.add_column(c4=self.null_args_fn(t.c1, t.c2))
 
         # data that tests all combinations of nulls
         data = [{'c1': 1.0, 'c2': 1.0}, {'c1': 1.0, 'c2': None}, {'c1': None, 'c2': 1.0}, {'c1': None, 'c2': None}]
@@ -513,9 +522,10 @@ class TestExprs:
         ][t.img, t.split].show()
         print(result)
 
-    def test_similarity(self, indexed_img_tbl: catalog.Table) -> None:
+    @pytest.mark.skip(reason='temporarily disabled')
+    def test_similarity(self, small_img_tbl) -> None:
         skip_test_if_not_installed('nos')
-        t = indexed_img_tbl
+        t = small_img_tbl
         _ = t.show(30)
         probe = t.select(t.img, t.category).show(1)
         img = probe[0, 0]
@@ -656,68 +666,67 @@ class TestExprs:
             # nested aggregates
             _ = t[sum(count(t.c2))].group_by(t.c2 % 2).show()
 
+    @pxt.uda(
+        init_types=[IntType()], update_types=[IntType()], value_type=IntType(),
+        allows_window=True, requires_order_by=False)
+    class window_agg:
+        def __init__(self, val: int = 0):
+            self.val = val
+        def update(self, ignore: int) -> None:
+            pass
+        def value(self) -> int:
+            return self.val
+
+    @pxt.uda(
+        init_types=[IntType()], update_types=[IntType()], value_type=IntType(),
+        requires_order_by=True, allows_window=True)
+    class ordered_agg:
+        def __init__(self, val: int = 0):
+            self.val = val
+        def update(self, i: int) -> None:
+            pass
+        def value(self) -> int:
+            return self.val
+
+    @pxt.uda(
+        init_types=[IntType()], update_types=[IntType()], value_type=IntType(),
+        requires_order_by=False, allows_window=False)
+    class std_agg:
+        def __init__(self, val: int = 0):
+            self.val = val
+        def update(self, i: int) -> None:
+            pass
+        def value(self) -> int:
+            return self.val
+
     def test_udas(self, test_tbl: catalog.Table) -> None:
         t = test_tbl
-
-        @pxt.uda(
-            name='window_agg', init_types=[IntType()], update_types=[IntType()], value_type=IntType(),
-            allows_window=True, requires_order_by=False)
-        class WindowAgg:
-            def __init__(self, val: int = 0):
-                self.val = val
-            def update(self, ignore: int) -> None:
-                pass
-            def value(self) -> int:
-                return self.val
-
-        @pxt.uda(
-            name='ordered_agg', init_types=[IntType()], update_types=[IntType()], value_type=IntType(),
-            requires_order_by=True, allows_window=True)
-        class WindowAgg:
-            def __init__(self, val: int = 0):
-                self.val = val
-            def update(self, i: int) -> None:
-                pass
-            def value(self) -> int:
-                return self.val
-
-        @pxt.uda(
-            name='std_agg', init_types=[IntType()], update_types=[IntType()], value_type=IntType(),
-            requires_order_by=False, allows_window=False)
-        class StdAgg:
-            def __init__(self, val: int = 0):
-                self.val = val
-            def update(self, i: int) -> None:
-                pass
-            def value(self) -> int:
-                return self.val
-
         # init arg is passed along
-        assert t.select(out=window_agg(t.c2, order_by=t.c2)).collect()[0]['out'] == 0
-        assert t.select(out=window_agg(t.c2, val=1, order_by=t.c2)).collect()[0]['out'] == 1
+        assert t.select(out=self.window_agg(t.c2, order_by=t.c2)).collect()[0]['out'] == 0
+        assert t.select(out=self.window_agg(t.c2, val=1, order_by=t.c2)).collect()[0]['out'] == 1
 
         with pytest.raises(excs.Error) as exc_info:
-            _ = t.select(window_agg(t.c2, val=t.c2, order_by=t.c2)).collect()
+            _ = t.select(self.window_agg(t.c2, val=t.c2, order_by=t.c2)).collect()
         assert 'needs to be a constant' in str(exc_info.value)
 
         with pytest.raises(excs.Error) as exc_info:
             # ordering expression not a pixeltable expr
-            _ = t.select(ordered_agg(1, t.c2)).collect()
+            _ = t.select(self.ordered_agg(1, t.c2)).collect()
         assert 'but instead is a' in str(exc_info.value).lower()
 
         with pytest.raises(excs.Error) as exc_info:
             # explicit order_by
-            _ = t.select(ordered_agg(t.c2, order_by=t.c2)).collect()
+            _ = t.select(self.ordered_agg(t.c2, order_by=t.c2)).collect()
         assert 'order_by invalid' in str(exc_info.value).lower()
 
         with pytest.raises(excs.Error) as exc_info:
             # order_by for non-window function
-            _ = t.select(std_agg(t.c2, order_by=t.c2)).collect()
+            _ = t.select(self.std_agg(t.c2, order_by=t.c2)).collect()
         assert 'does not allow windows' in str(exc_info.value).lower()
 
         with pytest.raises(excs.Error) as exc_info:
             # group_by for non-window function
-            _ = t.select(std_agg(t.c2, group_by=t.c4)).collect()
+            _ = t.select(self.std_agg(t.c2, group_by=t.c4)).collect()
         assert 'group_by invalid' in str(exc_info.value).lower()
 
         with pytest.raises(excs.Error) as exc_info:
@@ -768,18 +777,6 @@ class TestExprs:
                     return self.val
         assert 'cannot have parameters with the same name: val' in str(exc_info.value)
 
-        with pytest.raises(excs.Error) as exc_info:
-            # invalid name
-            @pxt.uda(name='not an identifier', init_types=[IntType()], update_types=[IntType()], value_type=IntType())
-            class WindowAgg:
-                def __init__(self, val: int = 0):
-                    self.val = val
-                def update(self, i1: int, i2: int) -> None:
-                    pass
-                def value(self) -> int:
-                    return self.val
-        assert 'invalid name' in str(exc_info.value).lower()
-
         with pytest.raises(excs.Error) as exc_info:
             # reserved parameter name
             @pxt.uda(init_types=[IntType()], update_types=[IntType()], value_type=IntType())

pixeltable/tests/test_function.py

@@ -20,8 +20,8 @@ class TestFunction:
     def func(x: int) -> int:
         return x + 1
 
-    @pxt.uda(name='agg', value_type=IntType(), update_types=[IntType()])
-    class Aggregator:
+    @pxt.uda(value_type=IntType(), update_types=[IntType()])
+    class agg:
         def __init__(self):
             self.sum = 0
         def update(self, val: int) -> None:
@@ -160,61 +160,62 @@ class TestFunction:
         assert status.num_rows == len(rows)
         assert status.num_excs == 0
 
+    @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
+
+    @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)
+
     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']
+        r1 = t[self.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']
+        r2 = t[self.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']
+        r3 = t[self.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']
+        r4 = t[self.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']
+        r5 = t[self.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']
+        r6 = t[self.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']
+        r6 = t[self.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']
+        r0 = t[self.f2(1, t.c3)].show(0).to_pandas()['col_0']
+        r1 = t[self.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']
+        r2 = t[self.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']
+        r3 = t[self.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']
+        r4 = t[self.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)
+            _ = t[self.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)
+            _ = t[self.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)
+            _ = t[self.f1(c=1.0, a=t.c2)].show(0)
         assert "'b'" in str(exc_info.value)
 
         # bad default value
@@ -242,17 +243,32 @@ class TestFunction:
                 return order_by
         assert 'reserved' in str(exc_info.value)
 
+    @pxt.expr_udf
+    def add1(x: int) -> int:
+        return x + 1
+
+    @pxt.expr_udf
+    def add2(x: int, y: int):
+        return x + y
+
+    @pxt.expr_udf
+    def add2_with_default(x: int, y: int = 1) -> int:
+        return x + y
+
     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()
+
+        res1 = t.select(out=self.add1(t.c2)).order_by(t.c2).collect()
+        res2 = t.select(t.c2 + 1).order_by(t.c2).collect()
+        assert_resultset_eq(res1, res2)
+
+        # return type inferred from expression
+        res1 = t.select(out=self.add2(t.c2, 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()
+            _ = t.select(self.add1(y=t.c2)).collect()
         assert 'missing a required argument' in str(exc_info.value).lower()
 
         with pytest.raises(excs.Error) as exc_info:
@@ -262,13 +278,6 @@ class TestFunction:
                 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()])
@@ -280,14 +289,13 @@ class TestFunction:
             # signature has correct parameter kind
             @pxt.expr_udf
             def add1(*, x: int) -> int:
-                return x + 1
+                return x + y
             _ = 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()
+        res1 = t.select(out=self.add2_with_default(t.c2)).order_by(t.c2).collect()
+        res2 = t.select(out=self.add2(t.c2, 1)).order_by(t.c2).collect()
+        assert_resultset_eq(res1, res2)
 
     # Test that various invalid udf definitions generate
     # correct error messages.

pixeltable/tests/test_index.py

@@ -0,0 +1,138 @@
+import PIL.Image
+import numpy as np
+import pytest
+
+import pixeltable as pxt
+from pixeltable.functions.huggingface import clip_image, clip_text
+from pixeltable.tests.utils import text_embed, img_embed, skip_test_if_not_installed
+
+
+class TestIndex:
+
+    # wrong signature
+    @pxt.udf
+    def bad_embed(x: str) -> str:
+        return x
+
+    def test_embedding_basic(self, img_tbl: pxt.Table, test_tbl: pxt.Table) -> None:
+        skip_test_if_not_installed('transformers')
+        img_t = img_tbl
+        rows = list(img_t.select(img=img_t.img.fileurl, category=img_t.category, split=img_t.split).collect())
+        # create table with fewer rows to speed up testing
+        cl = pxt.Client()
+        schema = {
+            'img': pxt.ImageType(nullable=False),
+            'category': pxt.StringType(nullable=False),
+            'split': pxt.StringType(nullable=False),
+        }
+        tbl_name = 'index_test'
+        img_t = cl.create_table(tbl_name, schema=schema)
+        img_t.insert(rows[:30])
+
+        img_t.add_embedding_index('img', img_embed=img_embed, text_embed=text_embed)
+
+        with pytest.raises(pxt.Error) as exc_info:
+            # duplicate name
+            img_t.add_embedding_index('img', idx_name='idx0', img_embed=img_embed)
+        assert 'duplicate index name' in str(exc_info.value).lower()
+
+        img_t.add_embedding_index('category', text_embed=text_embed)
+        # revert() removes the index
+        img_t.revert()
+        with pytest.raises(pxt.Error) as exc_info:
+            img_t.drop_index(column_name='category')
+        assert 'does not have an index' in str(exc_info.value).lower()
+
+        rows = list(img_t.collect())
+        status = img_t.update({'split': 'other'}, where=img_t.split == 'test')
+        assert status.num_excs == 0
+
+        status = img_t.delete()
+        assert status.num_excs == 0
+
+        # revert delete()
+        img_t.revert()
+        # revert update()
+        img_t.revert()
+
+        # make sure we can still do DML after reloading the metadata
+        cl = pxt.Client(reload=True)
+        img_t = cl.get_table(tbl_name)
+        status = img_t.insert(rows)
+        assert status.num_excs == 0
+
+        status = img_t.update({'split': 'other'}, where=img_t.split == 'test')
+        assert status.num_excs == 0
+
+        status = img_t.delete()
+        assert status.num_excs == 0
+
+        # revert delete()
+        img_t.revert()
+        # revert update()
+        img_t.revert()
+
+        img_t.drop_index(idx_name='idx0')
+        with pytest.raises(pxt.Error) as exc_info:
+            img_t.drop_index(column_name='img')
+        assert 'does not have an index' in str(exc_info.value).lower()
+
+        # revert() makes the index reappear
+        img_t.revert()
+        with pytest.raises(pxt.Error) as exc_info:
+            img_t.add_embedding_index('img', idx_name='idx0', img_embed=img_embed)
+        assert 'duplicate index name' in str(exc_info.value).lower()
+
+        # dropping the indexed column also drops indices
+        img_t.drop_column('img')
+        with pytest.raises(pxt.Error) as exc_info:
+            img_t.drop_index(idx_name='idx0')
+        assert 'does not exist' in str(exc_info.value).lower()
+
+    def test_errors(self, img_tbl: pxt.Table, test_tbl: pxt.Table) -> None:
+        img_t = img_tbl
+        rows = list(img_t.select(img=img_t.img.fileurl, category=img_t.category, split=img_t.split).collect())
+        # create table with fewer rows to speed up testing
+        cl = pxt.Client()
+        schema = {
+            'img': pxt.ImageType(nullable=False),
+            'category': pxt.StringType(nullable=False),
+            'split': pxt.StringType(nullable=False),
+        }
+        tbl_name = 'index_test'
+        img_t = cl.create_table(tbl_name, schema=schema)
+        img_t.insert(rows[:30])
+
+        with pytest.raises(pxt.Error) as exc_info:
+            # unknown column
+            img_t.add_embedding_index('does_not_exist', idx_name='idx0', img_embed=img_embed)
+        assert 'column does_not_exist unknown' in str(exc_info.value).lower()
+
+        with pytest.raises(pxt.Error) as exc_info:
+            # wrong column type
+            test_tbl.add_embedding_index('c2', img_embed=img_embed)
+        assert 'requires string or image column' in str(exc_info.value).lower()
+
+        with pytest.raises(pxt.Error) as exc_info:
+            # missing embedding function
+            img_tbl.add_embedding_index('img', text_embed=text_embed)
+        assert 'image embedding function is required' in str(exc_info.value).lower()
+
+        with pytest.raises(pxt.Error) as exc_info:
+            # wrong signature
+            img_tbl.add_embedding_index('img', img_embed=clip_image)
+        assert 'but has signature' in str(exc_info.value).lower()
+
+        with pytest.raises(pxt.Error) as exc_info:
+            # missing embedding function
+            img_tbl.add_embedding_index('category', img_embed=img_embed)
+        assert 'text embedding function is required' in str(exc_info.value).lower()
+
+        with pytest.raises(pxt.Error) as exc_info:
+            # wrong signature
+            img_tbl.add_embedding_index('category', text_embed=clip_text)
+        assert 'but has signature' in str(exc_info.value).lower()
+
+        with pytest.raises(pxt.Error) as exc_info:
+            img_tbl.add_embedding_index('category', text_embed=self.bad_embed)
+        assert 'must return an array' in str(exc_info.value).lower()

pixeltable/tests/test_migration.py

@@ -1,6 +1,7 @@
 import glob
 import logging
 import os
+import platform
 import subprocess
 
 import pgserver
@@ -15,7 +16,7 @@ _logger = logging.getLogger('pixeltable')
 
 class TestMigration:
 
-    @pytest.mark.skip(reason='Suspended')
+    @pytest.mark.skipif(platform.system() == 'Windows', reason='Does not run on Windows')
     def test_db_migration(self, init_env) -> None:
         env = Env.get()
         pg_package_dir = os.path.dirname(pgserver.__file__)

pixeltable/tests/test_snapshot.py

@@ -5,7 +5,7 @@ import pytest
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
-from pixeltable.tests.utils import create_test_tbl, assert_resultset_eq
+from pixeltable.tests.utils import create_test_tbl, assert_resultset_eq, create_img_tbl, img_embed
 from pixeltable.type_system import IntType
 
 
@@ -89,6 +89,29 @@ class TestSnapshot:
                     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_errors(self, test_client: pxt.Client) -> None:
+        cl = test_client
+        tbl = create_test_tbl(client=cl)
+        snap = cl.create_view('snap', tbl, is_snapshot=True)
+
+        with pytest.raises(pxt.Error) as excinfo:
+            _ = snap.update({'c3': snap.c3 + 1.0})
+        assert 'cannot update a snapshot' in str(excinfo.value).lower()
+
+        with pytest.raises(pxt.Error) as excinfo:
+            _ = snap.batch_update([{'c3': 1.0, 'c2': 1}])
+        assert 'cannot update a snapshot' in str(excinfo.value).lower()
+
+        with pytest.raises(pxt.Error) as excinfo:
+            _ = snap.revert()
+        assert 'cannot revert a snapshot' in str(excinfo.value).lower()
+
+        with pytest.raises(pxt.Error) as excinfo:
+            img_tbl = create_img_tbl(cl)
+            snap = cl.create_view('img_snap', img_tbl, is_snapshot=True)
+            snap.add_embedding_index('img', img_embed=img_embed)
+        assert 'cannot add an index to a snapshot' in str(excinfo.value).lower()
+
     def test_views_of_snapshots(self, test_client: pxt.Client) -> None:
         cl = test_client
         t = cl.create_table('tbl', {'a': IntType()})