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

pixeltable/func/batched_function.py

@@ -1,53 +0,0 @@
-import inspect
-from typing import List, Dict, Any, Optional, Callable
-import abc
-
-from .function import Function
-from .signature import Signature
-
-
-class BatchedFunction(Function):
-    """Base class for functions that can run on batches"""
-
-    @abc.abstractmethod
-    def get_batch_size(self, *args: Any, **kwargs: Any) -> Optional[int]:
-        """Return the batch size for the given arguments, or None if the batch size is unknown.
-        args/kwargs might be empty
-        """
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def invoke(self, arg_batches: List[List[Any]], kwarg_batches: Dict[str, List[Any]]) -> List[Any]:
-        """Invoke the function for the given batch and return a batch of results"""
-        raise NotImplementedError
-
-
-class ExplicitBatchedFunction(BatchedFunction):
-    """
-    A `BatchedFunction` that is defined by a signature and an explicit python
-    `Callable`.
-    """
-    def __init__(self, signature: Signature, batch_size: Optional[int], invoker_fn: Callable, self_path: str):
-        super().__init__(signature=signature, py_signature=inspect.signature(invoker_fn), self_path=self_path)
-        self.batch_size = batch_size
-        self.invoker_fn = invoker_fn
-
-    def get_batch_size(self, *args: Any, **kwargs: Any) -> Optional[int]:
-        return self.batch_size
-
-    def invoke(self, arg_batches: List[List[Any]], kwarg_batches: Dict[str, List[Any]]) -> List[Any]:
-        """Invoke the function for the given batch and return a batch of results"""
-        constant_param_names = [p.name for p in self.signature.constant_parameters]
-        kwargs = {k: v[0] for k, v in kwarg_batches.items() if k in constant_param_names}
-        kwarg_batches = {k: v for k, v in kwarg_batches.items() if k not in constant_param_names}
-        return self.invoker_fn(*arg_batches, **kwargs, **kwarg_batches)
-
-    def validate_call(self, bound_args: Dict[str, Any]) -> None:
-        """Verify constant parameters"""
-        import pixeltable.exprs as exprs
-        for param in self.signature.constant_parameters:
-            if param.name in bound_args and isinstance(bound_args[param.name], exprs.Expr):
-                raise ValueError(
-                    f'{self.display_name}(): '
-                    f'parameter {param.name} must be a constant value, not a Pixeltable expression'
-                )

pixeltable/tests/conftest.py

@@ -1,171 +0,0 @@
-import json
-import logging
-import os
-import pathlib
-from typing import List
-
-import numpy as np
-import pytest
-import PIL.Image
-
-import pixeltable as pxt
-import pixeltable.catalog as catalog
-from pixeltable import exprs
-import pixeltable.functions as pxtf
-from pixeltable.exprs import RELATIVE_PATH_ROOT as R
-from pixeltable.metadata import SystemInfo, create_system_info
-from pixeltable.metadata.schema import TableSchemaVersion, TableVersion, Table, Function, Dir
-from pixeltable.tests.utils import read_data_file, create_test_tbl, create_all_datatypes_tbl, skip_test_if_not_installed
-from pixeltable.type_system import StringType, ImageType, FloatType
-
-
-@pytest.fixture(scope='session')
-def init_env(tmp_path_factory) -> None:
-    from pixeltable.env import Env
-    # set the relevant env vars for Client() to connect to the test db
-
-    shared_home = pathlib.Path(os.environ.get('PIXELTABLE_HOME', str(pathlib.Path.home() / '.pixeltable')))
-    home_dir = str(tmp_path_factory.mktemp('base') / '.pixeltable')
-    os.environ['PIXELTABLE_HOME'] = home_dir
-    os.environ['PIXELTABLE_CONFIG'] = str(shared_home / 'config.yaml')
-    test_db = 'test'
-    os.environ['PIXELTABLE_DB'] = test_db
-    os.environ['PIXELTABLE_PGDATA'] = str(shared_home / 'pgdata')
-
-    # ensure this home dir exits
-    shared_home.mkdir(parents=True, exist_ok=True)
-    # this also runs create_all()
-    Env.get().set_up(echo=True)
-    yield
-    # leave db in place for debugging purposes
-
-@pytest.fixture(scope='function')
-def test_client(init_env) -> pxt.Client:
-    # Clean the DB *before* instantiating a client object. This is because some tests
-    # (such as test_migration.py) may leave the DB in a broken state, from which the
-    # client is uninstantiable.
-    clean_db()
-    cl = pxt.Client(reload=True)
-    cl.logging(level=logging.DEBUG, to_stdout=True)
-    yield cl
-
-
-def clean_db(restore_tables: bool = True) -> None:
-    from pixeltable.env import Env
-    # The logic from Client.reset_catalog() has been moved here, so that it
-    # does not rely on instantiating a Client object. As before, UUID-named data tables will
-    # not be cleaned. If in the future it is desirable to clean out data tables as well,
-    # the commented lines may be used to drop ALL tables from the test db.
-    # sql_md = declarative_base().metadata
-    # sql_md.reflect(Env.get().engine)
-    # sql_md.drop_all(bind=Env.get().engine)
-    engine = Env.get().engine
-    SystemInfo.__table__.drop(engine, checkfirst=True)
-    TableSchemaVersion.__table__.drop(engine, checkfirst=True)
-    TableVersion.__table__.drop(engine, checkfirst=True)
-    Table.__table__.drop(engine, checkfirst=True)
-    Function.__table__.drop(engine, checkfirst=True)
-    Dir.__table__.drop(engine, checkfirst=True)
-    if restore_tables:
-        Dir.__table__.create(engine)
-        Function.__table__.create(engine)
-        Table.__table__.create(engine)
-        TableVersion.__table__.create(engine)
-        TableSchemaVersion.__table__.create(engine)
-        SystemInfo.__table__.create(engine)
-        create_system_info(engine)
-
-
-@pytest.fixture(scope='function')
-def test_tbl(test_client: pxt.Client) -> catalog.Table:
-    return create_test_tbl(test_client)
-
-# @pytest.fixture(scope='function')
-# def test_stored_fn(test_client: pxt.Client) -> pxt.Function:
-#     @pxt.udf(return_type=pxt.IntType(), param_types=[pxt.IntType()])
-#     def test_fn(x):
-#         return x + 1
-#     test_client.create_function('test_fn', test_fn)
-#     return test_fn
-
-@pytest.fixture(scope='function')
-def test_tbl_exprs(test_tbl: catalog.Table) -> List[exprs.Expr]:
-#def test_tbl_exprs(test_tbl: catalog.Table, test_stored_fn: pxt.Function) -> List[exprs.Expr]:
-
-    t = test_tbl
-    return [
-        t.c1,
-        t.c7['*'].f1,
-        exprs.Literal('test'),
-        exprs.InlineDict({
-            'a': t.c1, 'b': t.c6.f1, 'c': 17,
-            'd': exprs.InlineDict({'e': t.c2}),
-            'f': exprs.InlineArray((t.c3, t.c3))
-        }),
-        exprs.InlineArray([[t.c2, t.c2], [t.c2, t.c2]]),
-        t.c2 > 5,
-        t.c2 == None,
-        ~(t.c2 > 5),
-        (t.c2 > 5) & (t.c1 == 'test'),
-        (t.c2 > 5) | (t.c1 == 'test'),
-        t.c7['*'].f5 >> [R[3], R[2], R[1], R[0]],
-        t.c8[0, 1:],
-        t.c2.astype(FloatType()),
-        (t.c2 + 1).astype(FloatType()),
-        t.c2.apply(str),
-        (t.c2 + 1).apply(str),
-        t.c3.apply(str),
-        t.c4.apply(str),
-        t.c5.apply(str),
-        t.c6.apply(str),
-        t.c1.apply(json.loads),
-        t.c8.errortype,
-        t.c8.errormsg,
-        pxtf.sum(t.c2, group_by=t.c4, order_by=t.c3),
-    ]
-
-@pytest.fixture(scope='function')
-def all_datatypes_tbl(test_client: pxt.Client) -> catalog.Table:
-    return create_all_datatypes_tbl(test_client)
-
-@pytest.fixture(scope='function')
-def img_tbl(test_client: pxt.Client) -> catalog.Table:
-    schema = {
-        'img': ImageType(nullable=False),
-        'category': StringType(nullable=False),
-        'split': StringType(nullable=False),
-    }
-    # this table is not indexed in order to avoid the cost of computing embeddings
-    tbl = test_client.create_table('test_img_tbl', schema)
-    rows = read_data_file('imagenette2-160', 'manifest.csv', ['img'])
-    tbl.insert(rows)
-    return tbl
-
-@pytest.fixture(scope='function')
-def img_tbl_exprs(img_tbl: catalog.Table) -> List[exprs.Expr]:
-    img_t = img_tbl
-    return [
-        img_t.img.width,
-        img_t.img.rotate(90),
-        # we're using a list here, not a tuple; the latter turns into a list during the back/forth conversion
-        img_t.img.rotate(90).resize([224, 224]),
-        img_t.img.fileurl,
-        img_t.img.localpath,
-    ]
-
-@pytest.fixture(scope='function')
-def small_img_tbl(test_client: pxt.Client) -> catalog.Table:
-    cl = test_client
-    schema = {
-        'img': ImageType(nullable=False),
-        'category': StringType(nullable=False),
-        'split': StringType(nullable=False),
-    }
-    tbl = cl.create_table('test_indexed_img_tbl', schema)
-    rows = read_data_file('imagenette2-160', 'manifest.csv', ['img'])
-    # select output_rows randomly in the hope of getting a good sample of the available categories
-    rng = np.random.default_rng(17)
-    idxs = rng.choice(np.arange(len(rows)), size=40, replace=False)
-    rows = [rows[i] for i in idxs]
-    tbl.insert(rows)
-    return tbl

pixeltable/tests/ext/test_yolox.py

@@ -1,21 +0,0 @@
-import pixeltable as pxt
-from pixeltable.tests.utils import skip_test_if_not_installed, get_image_files, validate_update_status
-
-
-class TestYolox:
-
-    def test_yolox(self, test_client: pxt.Client):
-        skip_test_if_not_installed('yolox')
-        from pixeltable.ext.functions.yolox import yolox
-        cl = test_client
-        t = cl.create_table('yolox_test', {'image': pxt.ImageType()})
-        t['detect_yolox_tiny'] = yolox(t.image, model_id='yolox_tiny')
-        t['detect_yolox_nano'] = yolox(t.image, model_id='yolox_nano', threshold=0.2)
-        t['yolox_nano_bboxes'] = t.detect_yolox_nano.bboxes
-        images = get_image_files()[:10]
-        validate_update_status(t.insert({'image': image} for image in images), expected_rows=10)
-        rows = t.collect()
-        # Verify correctly formed JSON
-        assert all(list(result.keys()) == ['bboxes', 'labels', 'scores'] for result in rows['detect_yolox_tiny'])
-        # Verify that bboxes are actually present in at least some of the rows.
-        assert any(len(bboxes) > 0 for bboxes in rows['yolox_nano_bboxes'])

pixeltable/tests/functions/test_fireworks.py

@@ -1,43 +0,0 @@
-import pytest
-
-import pixeltable as pxt
-import pixeltable.exceptions as excs
-from pixeltable.tests.utils import skip_test_if_not_installed, validate_update_status
-
-
-@pytest.mark.remote_api
-class TestFireworks:
-
-    def test_fireworks(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('fireworks')
-        TestFireworks.skip_test_if_no_fireworks_client()
-        cl = test_client
-        t = cl.create_table('test_tbl', {'input': pxt.StringType()})
-        from pixeltable.functions.fireworks import chat_completions
-        messages = [{'role': 'user', 'content': t.input}]
-        t['output'] = chat_completions(
-            messages=messages,
-            model='accounts/fireworks/models/llama-v2-7b-chat'
-        )
-        t['output_2'] = chat_completions(
-            messages=messages,
-            model='accounts/fireworks/models/llama-v2-7b-chat',
-            max_tokens=300,
-            top_k=40,
-            top_p=0.9,
-            temperature=0.7
-        )
-        validate_update_status(t.insert(input="How's everything going today?"), 1)
-        results = t.collect()
-        assert len(results['output'][0]['choices'][0]['message']['content']) > 0
-        assert len(results['output_2'][0]['choices'][0]['message']['content']) > 0
-
-    # This ensures that the test will be skipped, rather than returning an error, when no API key is
-    # available (for example, when a PR runs in CI).
-    @staticmethod
-    def skip_test_if_no_fireworks_client() -> None:
-        try:
-            import pixeltable.functions.fireworks
-            _ = pixeltable.functions.fireworks.fireworks_client()
-        except excs.Error as exc:
-            pytest.skip(str(exc))

pixeltable/tests/functions/test_functions.py

@@ -1,60 +0,0 @@
-import pixeltable as pxt
-from pixeltable import catalog
-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
-from pixeltable.type_system import VideoType, StringType
-
-
-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'}

pixeltable/tests/functions/test_huggingface.py

@@ -1,158 +0,0 @@
-from typing import Dict, Any
-
-import pytest
-
-import pixeltable as pxt
-from pixeltable.tests.utils import skip_test_if_not_installed, get_sentences, get_image_files, \
-    SAMPLE_IMAGE_URL
-from pixeltable.type_system import StringType, JsonType, ImageType, BoolType, FloatType, ArrayType
-
-
-class TestHuggingface:
-
-    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].is_array_type()
-            col_name = f'embed_img{idx}'
-            t[col_name] = clip_image(t.img, model_id=model_id)
-            assert t.column_types()[col_name].is_array_type()
-
-        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']

pixeltable/tests/functions/test_openai.py

@@ -1,162 +0,0 @@
-import pytest
-
-import pixeltable as pxt
-import pixeltable.exceptions as excs
-from pixeltable.tests.utils import SAMPLE_IMAGE_URL, skip_test_if_not_installed, validate_update_status
-from pixeltable.type_system import StringType, ImageType
-
-
-@pytest.mark.remote_api
-class TestOpenai:
-
-    def test_audio(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('openai')
-        TestOpenai.skip_test_if_no_openai_client()
-        cl = test_client
-        t = cl.create_table('test_tbl', {'input': StringType()})
-        from pixeltable.functions.openai import speech, transcriptions, translations
-        t.add_column(speech=speech(t.input, model='tts-1', voice='onyx'))
-        t.add_column(speech_2=speech(t.input, model='tts-1', voice='onyx', response_format='flac', speed=1.05))
-        t.add_column(transcription=transcriptions(t.speech, model='whisper-1'))
-        t.add_column(transcription_2=transcriptions(
-            t.speech, model='whisper-1', language='en', prompt='Transcribe the contents of this recording.'
-        ))
-        t.add_column(translation=translations(t.speech, model='whisper-1'))
-        t.add_column(translation_2=translations(
-            t.speech, model='whisper-1', prompt='Translate the recording from Spanish into English.', temperature=0.05
-        ))
-        validate_update_status(t.insert([
-            {'input': 'I am a banana.'},
-            {'input': 'Es fácil traducir del español al inglés.'}
-        ]), expected_rows=2)
-        # The audio generation -> transcription loop on these examples should be simple and clear enough
-        # that the unit test can reliably expect the output closely enough to pass these checks.
-        results = t.collect()
-        assert results[0]['transcription']['text'] in ['I am a banana.', "I'm a banana."]
-        assert results[0]['transcription_2']['text'] in ['I am a banana.', "I'm a banana."]
-        assert 'easy to translate' in results[1]['translation']['text']
-        assert 'easy to translate' in results[1]['translation_2']['text']
-
-    def test_chat_completions(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('openai')
-        TestOpenai.skip_test_if_no_openai_client()
-        cl = test_client
-        t = cl.create_table('test_tbl', {'input': StringType()})
-        from pixeltable.functions.openai import chat_completions
-        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_output_2=chat_completions(model='gpt-3.5-turbo', messages=msgs))
-        # test a bunch of the parameters
-        t.add_column(chat_output_3=chat_completions(
-            model='gpt-3.5-turbo', messages=msgs, frequency_penalty=0.1, logprobs=True, top_logprobs=3,
-            max_tokens=500, n=3, presence_penalty=0.1, seed=4171780, stop=['\n'], temperature=0.7, top_p=0.8,
-            user='pixeltable'
-        ))
-        # test with JSON output enforced
-        t.add_column(chat_output_4=chat_completions(
-            model='gpt-3.5-turbo', messages=msgs, response_format={'type': 'json_object'}
-        ))
-        # TODO Also test the `tools` and `tool_choice` parameters.
-        validate_update_status(t.insert(input='Give me an example of a typical JSON structure.'), 1)
-        result = t.collect()
-        assert len(result['chat_output'][0]['choices'][0]['message']['content']) > 0
-        assert len(result['chat_output_2'][0]['choices'][0]['message']['content']) > 0
-        assert len(result['chat_output_3'][0]['choices'][0]['message']['content']) > 0
-        assert len(result['chat_output_4'][0]['choices'][0]['message']['content']) > 0
-
-        # When OpenAI gets a request with `response_format` equal to `json_object`, but the prompt does not
-        # contain the string "json", it refuses the request.
-        # TODO This should probably not be throwing an exception, but rather logging the error in
-        # `t.chat_output_4.errormsg` etc.
-        with pytest.raises(excs.ExprEvalError) as exc_info:
-            t.insert(input='Say something interesting.')
-        assert "\\'messages\\' must contain the word \\'json\\'" in str(exc_info.value)
-
-    def test_gpt_4_vision(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('openai')
-        TestOpenai.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, vision
-        from pixeltable.functions.string import str_format
-        t.add_column(response=vision(prompt="What's in this image?", image=t.img))
-        # Also get the response the low-level way, by calling chat_completions
-        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_2=chat_completions(model='gpt-4-vision-preview', messages=msgs, max_tokens=300).choices[0].message.content)
-        validate_update_status(t.insert(prompt="What's in this image?", img=SAMPLE_IMAGE_URL), 1)
-        result = t.collect()['response_2'][0]
-        assert len(result) > 0
-
-    def test_embeddings(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('openai')
-        TestOpenai.skip_test_if_no_openai_client()
-        cl = test_client
-        from pixeltable.functions.openai import embeddings
-        t = cl.create_table('test_tbl', {'input': StringType()})
-        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, user='pixeltable'))
-        validate_update_status(t.insert(input='Say something interesting.'), 1)
-        _ = t.head()
-
-    def test_moderations(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('openai')
-        TestOpenai.skip_test_if_no_openai_client()
-        cl = test_client
-        t = cl.create_table('test_tbl', {'input': StringType()})
-        from pixeltable.functions.openai import moderations
-        t.add_column(moderation=moderations(input=t.input))
-        t.add_column(moderation_2=moderations(input=t.input, model='text-moderation-stable'))
-        validate_update_status(t.insert(input='Say something interesting.'), 1)
-        _ = t.head()
-
-    def test_image_generations(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('openai')
-        TestOpenai.skip_test_if_no_openai_client()
-        cl = test_client
-        t = cl.create_table('test_tbl', {'input': StringType()})
-        from pixeltable.functions.openai import image_generations
-        t.add_column(img=image_generations(t.input))
-        # Test dall-e-2 options
-        t.add_column(img_2=image_generations(
-            t.input, model='dall-e-2', size='512x512', user='pixeltable'
-        ))
-        validate_update_status(t.insert(input='A friendly dinosaur playing tennis in a cornfield'), 1)
-        assert t.collect()['img'][0].size == (1024, 1024)
-        assert t.collect()['img_2'][0].size == (512, 512)
-
-    @pytest.mark.skip('Test is expensive and slow')
-    def test_image_generations_dall_e_3(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('openai')
-        TestOpenai.skip_test_if_no_openai_client()
-        cl = test_client
-        t = cl.create_table('test_tbl', {'input': StringType()})
-        from pixeltable.functions.openai import image_generations
-        # Test dall-e-3 options
-        t.add_column(img_3=image_generations(
-            t.input, model='dall-e-3', quality='hd', size='1792x1024', style='natural', user='pixeltable'
-        ))
-        validate_update_status(t.insert(input='A friendly dinosaur playing tennis in a cornfield'), 1)
-        assert t.collect()['img_3'][0].size == (1792, 1024)
-
-    # This ensures that the test will be skipped, rather than returning an error, when no API key is
-    # available (for example, when a PR runs in CI).
-    @staticmethod
-    def skip_test_if_no_openai_client() -> None:
-        try:
-            import pixeltable.functions.openai
-            _ = pixeltable.functions.openai.openai_client()
-        except excs.Error as exc:
-            pytest.skip(str(exc))