pixeltable 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

pixeltable/iterators/string.py

@@ -0,0 +1,40 @@
+from typing import Iterator, Any
+
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
+from pixeltable.env import Env
+from pixeltable.iterators.base import ComponentIterator
+
+
+class StringSplitter(ComponentIterator):
+    # TODO(aaron-siegel): Merge this with `DocumentSplitter` in order to provide additional capabilities.
+    def __init__(self, text: str, *, separators: str):
+        if separators != 'sentence':
+            raise excs.Error('Only `sentence` separators are currently supported.')
+        self._text = text
+        self.doc = Env.get().spacy_nlp(self._text)
+        self.iter = self._iter()
+
+    def _iter(self) -> Iterator[dict[str, Any]]:
+        for sentence in self.doc.sents:
+            yield {'text': sentence.text}
+
+    def __next__(self) -> dict[str, Any]:
+        return next(self.iter)
+
+    def close(self) -> None:
+        pass
+
+    def set_pos(self, pos: int) -> None:
+        pass
+
+    @classmethod
+    def input_schema(cls, *args: Any, **kwargs: Any) -> dict[str, ts.ColumnType]:
+        return {
+            'text': ts.StringType(),
+            'separators': ts.StringType(),
+        }
+
+    @classmethod
+    def output_schema(cls,  *args: Any, **kwargs: Any) -> tuple[dict[str, ts.ColumnType], list[str]]:
+        return {'text': ts.StringType()}, []

pixeltable/metadata/__init__.py

@@ -10,7 +10,7 @@ import sqlalchemy.orm as orm
 from .schema import SystemInfo, SystemInfoMd
 
 # current version of the metadata; this is incremented whenever the metadata schema changes
-VERSION = 15
+VERSION = 17
 
 
 def create_system_info(engine: sql.engine.Engine) -> None:
@@ -26,13 +26,11 @@ def create_system_info(engine: sql.engine.Engine) -> None:
 # key: old schema version
 converter_cbs: Dict[int, Callable[[sql.engine.Engine], None]] = {}
 
-def register_converter(version: int, cb: Callable[[sql.engine.Engine], None]) -> None:
-    global converter_cbs
-    converter_cbs[version] = cb
-
-def noop_converter(engine: sql.engine.Engine) -> None:
-    # Converter to use when incrementing the schema version, but without any functional changes
-    pass
+def register_converter(version: int) -> Callable[[Callable[[sql.engine.Engine], None]], None]:
+    def decorator(fn: Callable[[sql.engine.Engine], None]) -> None:
+        global converter_cbs
+        converter_cbs[version] = fn
+    return decorator
 
 # load all converter modules
 for _, modname, _ in pkgutil.iter_modules([os.path.dirname(__file__) + '/converters']):

pixeltable/metadata/converters/convert_10.py

@@ -4,7 +4,8 @@ from pixeltable.metadata.schema import Table, TableSchemaVersion
 from pixeltable.metadata import register_converter
 
 
-def convert_10(engine: sql.engine.Engine) -> None:
+@register_converter(version=10)
+def _(engine: sql.engine.Engine) -> None:
     default_table_attrs = {"comment": None, "num_retained_versions": 10}
     with engine.begin() as conn:
         # Because `parameters` wasn't actually used for anything,
@@ -13,6 +14,3 @@ def convert_10(engine: sql.engine.Engine) -> None:
         # Add `table_attrs` to all instances of tableschemaversions.md.
         conn.execute(sql.update(TableSchemaVersion).values(md=TableSchemaVersion.md.concat(default_table_attrs)))
     return
-
-
-register_converter(10, convert_10)

pixeltable/metadata/converters/convert_12.py

@@ -1,3 +1,8 @@
-from pixeltable.metadata import register_converter, noop_converter
+import sqlalchemy as sql
 
-register_converter(12, noop_converter)
+from pixeltable.metadata import register_converter
+
+
+@register_converter(version=12)
+def _(engine: sql.engine.Engine) -> None:
+    pass

pixeltable/metadata/converters/convert_13.py

@@ -9,12 +9,13 @@ from pixeltable.metadata.schema import Table
 _logger = logging.getLogger('pixeltable')
 
 
-def convert_13(engine: sql.engine.Engine) -> None:
+@register_converter(version=13)
+def _(engine: sql.engine.Engine) -> None:
     with engine.begin() as conn:
         for row in conn.execute(sql.select(Table)):
             id = row[0]
             md = row[2]
-            updated_md = _update_md(md)
+            updated_md = __update_md(md)
             if updated_md != md:
                 _logger.info(f'Updating schema for table: {id}')
                 conn.execute(sql.update(Table).where(Table.id == id).values(md=updated_md))
@@ -23,19 +24,16 @@ def convert_13(engine: sql.engine.Engine) -> None:
 # Traverse the schema dictionary and replace instances of `ExplicitBatchedFunction` with
 # `CallableFunction`. DB versions prior to 14 can't contain serialized batched functions,
 # so this is all we need to do.
-def _update_md(md: Any) -> Any:
+def __update_md(md: Any) -> Any:
     if isinstance(md, dict):
         updated_md = {}
         for k, v in md.items():
             if k == '_classpath' and v == 'pixeltable.func.batched_function.ExplicitBatchedFunction':
                 updated_md[k] = 'pixeltable.func.callable_function.CallableFunction'
             else:
-                updated_md[k] = _update_md(v)
+                updated_md[k] = __update_md(v)
         return updated_md
     elif isinstance(md, list):
-        return [_update_md(v) for v in md]
+        return [__update_md(v) for v in md]
     else:
         return md
-
-
-register_converter(13, convert_13)

pixeltable/metadata/converters/convert_14.py

@@ -4,10 +4,8 @@ from pixeltable.metadata.schema import Table
 from pixeltable.metadata import register_converter
 
 
-def convert_14(engine: sql.engine.Engine) -> None:
+@register_converter(version=14)
+def _(engine: sql.engine.Engine) -> None:
     default_remotes = {'remotes': []}
     with engine.begin() as conn:
         conn.execute(sql.update(Table).where(Table.md['remotes'] == None).values(md=Table.md.concat(default_remotes)))
-
-
-register_converter(14, convert_14)

pixeltable/metadata/converters/convert_15.py

@@ -0,0 +1,44 @@
+
+import inspect
+import logging
+from typing import Any
+
+import cloudpickle
+import sqlalchemy as sql
+
+import pixeltable.func as func
+import pixeltable.type_system as ts
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.schema import Function
+
+_logger = logging.getLogger('pixeltable')
+
+
+@register_converter(version=15)
+def _(engine: sql.engine.Engine) -> None:
+    with engine.begin() as conn:
+        for row in conn.execute(sql.select(Function)):
+            id, dir_id, md, binary_obj = row
+            md['md'] = __update_md(md['md'], binary_obj)
+            _logger.info(f'Updating function: {id}')
+            conn.execute(sql.update(Function).where(Function.id == id).values(md=md))
+
+
+def __update_md(orig_d: dict, binary_obj: bytes) -> Any:
+    # construct dict produced by CallableFunction.to_store()
+    py_fn = cloudpickle.loads(binary_obj)
+    py_params = inspect.signature(py_fn).parameters
+    return_type = ts.ColumnType.from_dict(orig_d['return_type'])
+    params: list[func.Parameter] = []
+    for name, col_type_dict, kind_int, is_batched in orig_d['parameters']:
+        col_type = ts.ColumnType.from_dict(col_type_dict) if col_type_dict is not None else None
+        default = py_params[name].default
+        kind = inspect._ParameterKind(kind_int)  # is there a way to avoid referencing a private type?
+        params.append(func.Parameter(name=name, col_type=col_type, kind=kind, default=default, is_batched=is_batched))
+    is_batched = 'batch_size' in orig_d
+    sig = func.Signature(return_type, params, is_batched=is_batched)
+    d = {
+        'signature': sig.as_dict(),
+        'batch_size': orig_d['batch_size'] if is_batched else None,
+    }
+    return d

pixeltable/metadata/converters/convert_16.py

@@ -0,0 +1,18 @@
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+
+@register_converter(version=16)
+def _(engine: sql.engine.Engine) -> None:
+    convert_table_md(
+        engine,
+        table_md_updater=__update_table_md
+    )
+
+
+def __update_table_md(table_md: dict) -> None:
+    # External stores are not migratable; just drop them
+    del table_md['remotes']
+    table_md['external_stores'] = {}

pixeltable/metadata/converters/util.py

@@ -0,0 +1,66 @@
+import copy
+import logging
+from typing import Any, Callable, Optional
+
+import sqlalchemy as sql
+
+from pixeltable.metadata.schema import Table
+
+__logger = logging.getLogger('pixeltable')
+
+
+def convert_table_md(
+    engine: sql.engine.Engine,
+    table_md_updater: Optional[Callable[[dict], None]] = None,
+    column_md_updater: Optional[Callable[[dict], None]] = None,
+    external_store_md_updater: Optional[Callable[[dict], None]] = None,
+    substitution_fn: Optional[Callable[[Any, Any], Optional[tuple[Any, Any]]]] = None
+) -> None:
+    with engine.begin() as conn:
+        for row in conn.execute(sql.select(Table)):
+            id = row[0]
+            table_md = row[2]
+            assert isinstance(table_md, dict)
+            updated_table_md = copy.deepcopy(table_md)
+            if table_md_updater is not None:
+                table_md_updater(updated_table_md)
+            if column_md_updater is not None:
+                __update_column_md(updated_table_md, column_md_updater)
+            if external_store_md_updater is not None:
+                __update_external_store_md(updated_table_md, external_store_md_updater)
+            if substitution_fn is not None:
+                updated_table_md = __substitute_md_rec(updated_table_md, substitution_fn)
+            if updated_table_md != table_md:
+                __logger.info(f'Updating schema for table: {id}')
+                conn.execute(sql.update(Table).where(Table.id == id).values(md=updated_table_md))
+
+
+def __update_column_md(table_md: dict, column_md_updater: Callable[[dict], None]) -> None:
+    columns_md = table_md['column_md']
+    assert isinstance(columns_md, dict)
+    for column_md in columns_md.values():
+        column_md_updater(column_md)
+
+
+def __update_external_store_md(table_md: dict, external_store_md_updater: Callable[[dict], None]) -> None:
+    stores_md = table_md['external_stores']
+    assert isinstance(stores_md, list)
+    for store_md in stores_md:
+        external_store_md_updater(store_md)
+
+
+def __substitute_md_rec(md: Any, substitution_fn: Callable[[Any, Any], Optional[tuple[Any, Any]]]) -> Any:
+    if isinstance(md, dict):
+        updated_md = {}
+        for k, v in md.items():
+            substitute = substitution_fn(k, v)
+            if substitute is not None:
+                updated_k, updated_v = substitute
+                updated_md[updated_k] = updated_v
+            else:
+                updated_md[k] = __substitute_md_rec(v, substitution_fn)
+        return updated_md
+    elif isinstance(md, list):
+        return [__substitute_md_rec(v, substitution_fn) for v in md]
+    else:
+        return md

pixeltable/metadata/schema.py

@@ -142,9 +142,9 @@ class TableMd:
     # - every row is assigned a unique and immutable rowid on insertion
     next_row_id: int
 
-    # Metadata format for remotes:
-    # {'class': 'pixeltable.datatransfer.LabelStudioProject', 'md': {'project_id': 3}}
-    remotes: list[dict[str, Any]]
+    # Metadata format for external stores:
+    # {'class': 'pixeltable.io.label_studio.LabelStudioProject', 'md': {'project_id': 3}}
+    external_stores: list[dict[str, Any]]
 
     column_md: dict[int, ColumnMd]  # col_id -> ColumnMd
     index_md: dict[int, IndexMd]  # index_id -> IndexMd

pixeltable/plan.py

@@ -217,15 +217,15 @@ class Planner:
         plan = exec.InMemoryDataNode(tbl, rows, row_builder, tbl.next_rowid)
 
         media_input_cols = [info for info in input_col_info if info.col.col_type.is_media_type()]
+        if len(media_input_cols) > 0:
+            # prefetch external files for all input column refs for validation
+            plan = exec.CachePrefetchNode(tbl.id, media_input_cols, plan)
+            plan = exec.MediaValidationNode(row_builder, media_input_cols, input=plan)
 
-        # prefetch external files for all input column refs for validation
-        plan = exec.CachePrefetchNode(tbl.id, media_input_cols, plan)
-        plan = exec.MediaValidationNode(row_builder, media_input_cols, input=plan)
-
-        computed_exprs = row_builder.default_eval_ctx.target_exprs
+        computed_exprs = [e for e in row_builder.default_eval_ctx.target_exprs if not isinstance(e, exprs.ColumnRef)]
         if len(computed_exprs) > 0:
             # add an ExprEvalNode when there are exprs to compute
-            plan = exec.ExprEvalNode(row_builder, computed_exprs, [], input=plan)
+            plan = exec.ExprEvalNode(row_builder, computed_exprs, plan.output_exprs, input=plan)
 
         plan.set_stored_img_cols(stored_img_col_info)
         plan.set_ctx(
@@ -355,7 +355,8 @@ class Planner:
         # - we can ignore stored non-computed columns because they have a default value that is supplied directly by
         #   the store
         target = view.tbl_version  # the one we need to populate
-        stored_cols = [c for c in target.cols if c.is_stored and (c.is_computed or target.is_iterator_column(c))]
+        #stored_cols = [c for c in target.cols if c.is_stored and (c.is_computed or target.is_iterator_column(c))]
+        stored_cols = [c for c in target.cols if c.is_stored]
         # 2. for component views: iterator args
         iterator_args = [target.iterator_args] if target.iterator_args is not None else []
 

pixeltable/store.py

@@ -263,7 +263,7 @@ class StoreBase:
             number of inserted rows, number of exceptions, set of column ids that have exceptions
         """
         assert v_min is not None
-        exec_plan.ctx.conn = conn
+        exec_plan.ctx.set_conn(conn)
         batch_size = 16  # TODO: is this a good batch size?
         # TODO: total?
         num_excs = 0

pixeltable/tool/create_test_db_dump.py

@@ -4,6 +4,7 @@ import logging
 import os
 import pathlib
 import subprocess
+from typing import Any
 
 import pgserver
 import toml
@@ -12,8 +13,10 @@ import pixeltable as pxt
 import pixeltable.metadata as metadata
 from pixeltable.env import Env
 from pixeltable.func import Batch
+from pixeltable.io.external_store import Project
+from pixeltable.tool import embed_udf
 from pixeltable.type_system import \
-    StringType, IntType, FloatType, BoolType, TimestampType, JsonType
+    StringType, IntType, FloatType, BoolType, TimestampType, JsonType, ImageType
 
 _logger = logging.getLogger('pixeltable')
 
@@ -30,6 +33,8 @@ class Dumper:
         os.environ['PIXELTABLE_DB'] = db_name
         os.environ['PIXELTABLE_PGDATA'] = str(shared_home / 'pgdata')
 
+        Env._init_env(reinit_db=True)
+
         Env.get().configure_logging(level=logging.DEBUG, to_stdout=True)
 
     def dump_db(self) -> None:
@@ -62,8 +67,7 @@ class Dumper:
         with open(info_file, 'w') as info:
             toml.dump(info_dict, info)
 
-    # TODO: Add additional features to the test DB dump (ideally it should exercise
-    # every major pixeltable DB feature)
+    # Expression types, predicate types, embedding indices, views on views
     def create_tables(self) -> None:
         schema = {
             'c1': StringType(nullable=False),
@@ -74,29 +78,11 @@ class Dumper:
             'c5': TimestampType(nullable=False),
             'c6': JsonType(nullable=False),
             'c7': JsonType(nullable=False),
+            'c8': ImageType(nullable=True)
         }
-        t = pxt.create_table('sample_table', schema, primary_key='c2')
-
-        # Add columns for InlineArray and InlineDict
-        t.add_column(c8=[[1, 2, 3], [4, 5, 6]])
-        t.add_column(c9=[['a', 'b', 'c'], ['d', 'e', 'f']])
-        t.add_column(c10=[t.c1, [t.c1n, t.c2]])
-        t.add_column(c11={'int': 22, 'dict': {'key': 'val'}, 'expr': t.c1})
-
-        # InPredicate
-        t.add_column(isin_1=t.c1.isin(['test string 1', 'test string 2', 'test string 3']))
-        t.add_column(isin_2=t.c2.isin([1, 2, 3, 4, 5]))
-        t.add_column(isin_3=t.c2.isin(t.c6.f5))
-
-        # Add columns for .astype converters to ensure they're persisted properly
-        t.add_column(c2_as_float=t.c2.astype(FloatType()))
-
-        # Add columns for .apply
-        t.add_column(c2_to_string=t.c2.apply(str))
-        t.add_column(c6_to_string=t.c6.apply(json.dumps))
-        t.add_column(c6_back_to_json=t.c6_to_string.apply(json.loads))
+        t = pxt.create_table('base_table', schema, primary_key='c2')
 
-        num_rows = 100
+        num_rows = 20
         d1 = {
             'f1': 'test string 1',
             'f2': 1,
@@ -115,9 +101,8 @@ class Dumper:
         c3_data = [float(i) for i in range(num_rows)]
         c4_data = [bool(i % 2) for i in range(num_rows)]
         c5_data = [datetime.datetime.now()] * num_rows
-        c6_data = []
-        for i in range(num_rows):
-            d = {
+        c6_data = [
+            {
                 'f1': f'test string {i}',
                 'f2': i,
                 'f3': float(i),
@@ -128,8 +113,8 @@ class Dumper:
                     'f8': [1.0, 2.0, 3.0, 4.0],
                 },
             }
-            c6_data.append(d)
-
+            for i in range(num_rows)
+        ]
         c7_data = [d2] * num_rows
         rows = [
             {
@@ -141,40 +126,148 @@ class Dumper:
                 'c5': c5_data[i],
                 'c6': c6_data[i],
                 'c7': c7_data[i],
+                'c8': None
             }
             for i in range(num_rows)
         ]
+
+        self.__add_expr_columns(t, 'base_table')
         t.insert(rows)
+
         pxt.create_dir('views')
-        v = pxt.create_view('views.sample_view', t, filter=(t.c2 < 50))
-        _ = pxt.create_view('views.sample_snapshot', t, filter=(t.c2 >= 75), is_snapshot=True)
+
+        # simple view
+        v = pxt.create_view('views.view', t, filter=(t.c2 < 50))
+        self.__add_expr_columns(v, 'view')
+
+        # snapshot
+        _ = pxt.create_view('views.snapshot', t, filter=(t.c2 >= 75), is_snapshot=True)
+
+        # view of views
+        vv = pxt.create_view('views.view_of_views', v, filter=(t.c2 >= 25))
+        self.__add_expr_columns(vv, 'view_of_views')
+
+        # empty view
         e = pxt.create_view('views.empty_view', t, filter=t.c2 == 4171780)
         assert e.count() == 0
-        # Computed column using a library function
-        v['str_format'] = pxt.functions.string.str_format('{0} {key}', t.c1, key=t.c1)
-        # Computed column using a bespoke stored udf
-        v['test_udf'] = test_udf_stored(t.c2)
-        # Computed column using a batched function
-        # (apply this to the empty view, since it's a "heavyweight" function)
-        e['batched'] = pxt.functions.huggingface.clip_text(t.c1, model_id='openai/clip-vit-base-patch32')
-        # computed column using a stored batched function
-        v['test_udf_batched'] = test_udf_stored_batched(t.c1, upper=False)
-        # astype
-        v['astype'] = t.c1.astype(pxt.FloatType())
-
-        # Add remotes
-        from pixeltable.datatransfer.remote import MockRemote
-        v.link_remote(
-            MockRemote({'int_field': pxt.IntType()}, {'str_field': pxt.StringType()}),
-            col_mapping={'test_udf': 'int_field', 'c1': 'str_field'}
+        self.__add_expr_columns(e, 'empty_view', include_expensive_functions=True)
+
+        # Add external stores
+        from pixeltable.io.external_store import MockProject
+        v._link_external_store(
+            MockProject.create(
+                v,
+                'project',
+                {'int_field': pxt.IntType()},
+                {'str_field': pxt.StringType()},
+                {'view_test_udf': 'int_field', 'c1': 'str_field'}
+            )
         )
-        # We're just trying to test metadata here, so reach "under the covers" and link a fake
-        # Label Studio project without validation (so we don't need a real Label Studio server)
-        from pixeltable.datatransfer.label_studio import LabelStudioProject
-        v.tbl_version_path.tbl_version.link(
-            LabelStudioProject(4171780),
-            col_mapping={'str_format': 'str_format'}
+        # We're just trying to test metadata here, so it's ok to link a false Label Studio project.
+        # We include a computed image column in order to ensure the creation of a stored proxy.
+        from pixeltable.io.label_studio import LabelStudioProject
+        col_mapping = Project.validate_columns(
+            v, {'str_field': pxt.StringType(), 'img_field': pxt.ImageType()}, {},
+            {'view_function_call': 'str_field', 'base_table_image_rot': 'img_field'}
         )
+        project = LabelStudioProject('ls_project_0', 4171780, media_import_method='file', col_mapping=col_mapping)
+        v._link_external_store(project)
+        # Sanity check that the stored proxy column did get created
+        assert len(project.stored_proxies) == 1
+        assert t.base_table_image_rot.col in project.stored_proxies
+
+    def __add_expr_columns(self, t: pxt.Table, col_prefix: str, include_expensive_functions=False) -> None:
+        def add_column(col_name: str, col_expr: Any) -> None:
+            t.add_column(**{f'{col_prefix}_{col_name}': col_expr})
+        
+        # arithmetic_expr
+        add_column('plus', t.c2 + 6)
+        add_column('minus', t.c2 - 5)
+        add_column('times', t.c3 * 1.2)
+        add_column('div', t.c3 / 1.7)
+        add_column('mod', t.c2 % 11)
+
+        # array_slice
+        add_column('array_slice_1', t.c6[5])
+
+        # column_property_ref
+        add_column('fileurl', t.c8.fileurl)
+        add_column('localpath', t.c8.localpath)
+
+        # comparison
+        add_column('lt', t.c2 < t.c3)
+        add_column('le', t.c2 <= t.c3)
+        add_column('gt', t.c2 > t.c3)
+        add_column('ge', t.c2 >= t.c3)
+        add_column('ne', t.c2 != t.c3)
+        add_column('eq', t.c2 == t.c3)
+
+        # compound_predicate
+        add_column('and', (t.c2 >= 5) & (t.c2 < 8))
+        add_column('or', (t.c2 > 1) | t.c4)
+        add_column('not', ~(t.c2 > 20))
+
+        # function_call
+        add_column('function_call', pxt.functions.string.str_format('{0} {key}', t.c1, key=t.c1))  # library function
+        add_column('test_udf', test_udf_stored(t.c2))  # stored udf
+        add_column('test_udf_batched', test_udf_stored_batched(t.c1, upper=False))  # batched stored udf
+        if include_expensive_functions:
+            # batched library function
+            add_column('batched', pxt.functions.huggingface.clip_text(t.c1, model_id='openai/clip-vit-base-patch32'))
+
+        # image_member_access
+        add_column('image_mode', t.c8.mode)
+        add_column('image_rot', t.c8.rotate(180))
+
+        # in_predicate
+        add_column('isin_1', t.c1.isin(['test string 1', 'test string 2', 'test string 3']))
+        add_column('isin_2', t.c2.isin([1, 2, 3, 4, 5]))
+        add_column('isin_3', t.c2.isin(t.c6.f5))
+
+        # inline_array and inline_dict
+        add_column('inline_array_1', [[1, 2, 3], [4, 5, 6]])
+        add_column('inline_array_2', [['a', 'b', 'c'], ['d', 'e', 'f']])
+        add_column('inline_list_exprs', [t.c1, [t.c1n, t.c2]])
+        add_column('inline_list_mixed', [1, 'a', t.c1, [1, 'a', t.c1n], 1, 'a'])
+        add_column('inline_dict', {'int': 22, 'dict': {'key': 'val'}, 'expr': t.c1})
+
+        # is_null
+        add_column('isnull', t.c1 == None)
+
+        # json_mapper and json_path
+        add_column('json_mapper', t.c6[3])
+        add_column('json_path', t.c6.f1)
+
+        # literal
+        add_column('str_const', 'str')
+        add_column('int_const', 5)
+        add_column('float_const', 5.0)
+        add_column('timestamp_const_1', datetime.datetime.utcnow())
+        add_column('timestamp_const_2', datetime.date.today())
+
+        # type_cast
+        add_column('astype', t.c2.astype(FloatType()))
+
+        # .apply
+        add_column('c2_to_string', t.c2.apply(str))
+        add_column('c6_to_string', t.c6.apply(json.dumps))
+        add_column('c6_back_to_json', t[f'{col_prefix}_c6_to_string'].apply(json.loads))
+
+        t.add_embedding_index(f'{col_prefix}_function_call', text_embed=embed_udf.clip_text_embed)
+
+        # query()
+        @t.query
+        def q1(i: int):
+            # this breaks; TODO: why?
+            #return t.where(t.c2 < i)
+            return t.where(t.c2 < i).select(t.c1, t.c2)
+        add_column('query_output', t.q1(t.c2))
+
+        @t.query
+        def q2(s: str):
+            sim = t[f'{col_prefix}_function_call'].similarity(s)
+            return t.order_by(sim, asc=False).select(t[f'{col_prefix}_function_call']).limit(5)
+        add_column('sim_output', t.q2(t.c1))
 
 
 @pxt.udf(_force_stored=True)

pixeltable/tool/embed_udf.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+import pixeltable as pxt
+
+
+# TODO This can go away once we have the ability to inline expr_udf's
+@pxt.expr_udf
+def clip_text_embed(txt: str) -> np.ndarray:
+    return pxt.functions.huggingface.clip_text(txt, model_id='openai/clip-vit-base-patch32')

pixeltable/type_system.py

@@ -160,7 +160,7 @@ class ColumnType:
         if t == cls.Type.AUDIO:
             return AudioType()
         if t == cls.Type.DOCUMENT:
-            return AudioType()
+            return DocumentType()
 
     def __str__(self) -> str:
         return self._type.name.lower()
@@ -250,7 +250,6 @@ class ColumnType:
                 return None
         return None
 
-
     @classmethod
     def from_python_type(cls, t: type) -> Optional[ColumnType]:
         if typing.get_origin(t) is typing.Union: