pixeltable 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

pixeltable/__init__.py

@@ -3,8 +3,8 @@ from .dataframe import DataFrame
 from .exceptions import Error
 from .exprs import RELATIVE_PATH_ROOT
 from .func import Function, udf, Aggregator, uda, expr_udf
-from .globals import init, create_table, create_view, get_table, move, drop_table, list_tables, create_dir, rm_dir, \
-    list_dirs, list_functions, get_path, configure_logging
+from .globals import init, create_table, create_view, get_table, move, drop_table, list_tables, create_dir, drop_dir, \
+    list_dirs, list_functions, configure_logging
 from .type_system import (
     ColumnType,
     StringType,

pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.2.11"
-__version_tuple__ = (0, 2, 11)
+__version__ = "0.2.13"
+__version_tuple__ = (0, 2, 13)

pixeltable/catalog/insertable_table.py

@@ -129,11 +129,11 @@ class InsertableTable(Table):
                     msg = str(e)
                     raise excs.Error(f'Error in column {col.name}: {msg[0].lower() + msg[1:]}\nRow: {row}')
 
-    def delete(self, where: Optional['pixeltable.exprs.Predicate'] = None) -> UpdateStatus:
+    def delete(self, where: Optional['pixeltable.exprs.Expr'] = None) -> UpdateStatus:
         """Delete rows in this table.
 
         Args:
-            where: a Predicate to filter rows to delete.
+            where: a predicate to filter rows to delete.
 
         Examples:
             Delete all rows in a table:

pixeltable/catalog/schema_object.py

@@ -1,7 +1,10 @@
 from abc import abstractmethod
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 from uuid import UUID
 
+if TYPE_CHECKING:
+    from pixeltable import catalog
+
 
 class SchemaObject:
     """
@@ -17,9 +20,32 @@ class SchemaObject:
     def _get_id(self) -> UUID:
         return self._id
 
-    def get_name(self) -> str:
+    @property
+    def name(self) -> str:
+        """Returns the name of this schema object."""
         return self._name
 
+    @property
+    def parent(self) -> Optional['catalog.Dir']:
+        """Returns the parent directory of this schema object."""
+        from pixeltable import catalog
+        if self._dir_id is None:
+            return None
+        dir = catalog.Catalog.get().paths.get_schema_obj(self._dir_id)
+        assert isinstance(dir, catalog.Dir)
+        return dir
+
+    @property
+    def path(self) -> str:
+        """Returns the path to this schema object."""
+        parent = self.parent
+        if parent is None or parent.parent is None:
+            # Either this is the root directory, with empty path, or its parent is the
+            # root directory. Either way, we return just the name.
+            return self.name
+        else:
+            return f'{parent.path}.{self.name}'
+
     @classmethod
     @abstractmethod
     def display_name(cls) -> str:

pixeltable/catalog/table.py

@@ -82,14 +82,22 @@ class Table(SchemaObject):
             return self._queries[index]
         return self._tbl_version_path.__getitem__(index)
 
-    def get_views(self, *, recursive: bool = False) -> list['Table']:
+    def list_views(self, *, recursive: bool = True) -> list[str]:
         """
-        All views and snapshots of this `Table`.
+        Returns a list of all views and snapshots of this `Table`.
+
+        Args:
+            recursive: If `False`, returns only the immediate successor views of this `Table`. If `True`, returns
+                all sub-views (including views of views, etc.)
         """
+        return [t.path for t in self._get_views(recursive=recursive)]
+
+    def _get_views(self, *, recursive: bool = True) -> list['Table']:
+        dependents = catalog.Catalog.get().tbl_dependents[self._get_id()]
         if recursive:
-            return [self] + [t for view in self.get_views(recursive=False) for t in view.get_views(recursive=True)]
+            return dependents + [t for view in dependents for t in view._get_views(recursive=True)]
         else:
-            return catalog.Catalog.get().tbl_dependents[self._get_id()]
+            return dependents
 
     def _df(self) -> 'pixeltable.dataframe.DataFrame':
         """Return a DataFrame for this table.
@@ -105,7 +113,7 @@ class Table(SchemaObject):
         from pixeltable.dataframe import DataFrame
         return DataFrame(self._tbl_version_path).select(*items, **named_items)
 
-    def where(self, pred: 'exprs.Predicate') -> 'pixeltable.dataframe.DataFrame':
+    def where(self, pred: 'exprs.Expr') -> 'pixeltable.dataframe.DataFrame':
         """Return a DataFrame for this table.
         """
         # local import: avoid circular imports
@@ -500,7 +508,37 @@ class Table(SchemaObject):
             >>> tbl.drop_column('factorial')
         """
         self._check_is_dropped()
-        self._tbl_version.drop_column(name)
+
+        if name not in self._tbl_version.cols_by_name:
+            raise excs.Error(f'Unknown column: {name}')
+        col = self._tbl_version.cols_by_name[name]
+
+        dependent_user_cols = [c for c in col.dependent_cols if c.name is not None]
+        if len(dependent_user_cols) > 0:
+            raise excs.Error(
+                f'Cannot drop column `{name}` because the following columns depend on it:\n'
+                f'{", ".join(c.name for c in dependent_user_cols)}'
+            )
+
+        # See if this column has a dependent store. We need to look through all stores in all
+        # (transitive) views of this table.
+        dependent_stores = [
+            (view, store)
+            for view in [self] + self._get_views(recursive=True)
+            for store in view._tbl_version.external_stores.values()
+            if col in store.get_local_columns()
+        ]
+        if len(dependent_stores) > 0:
+            dependent_store_names = [
+                store.name if view._get_id() == self._get_id() else f'{store.name} (in view `{view.name}`)'
+                for view, store in dependent_stores
+            ]
+            raise excs.Error(
+                f'Cannot drop column `{name}` because the following external stores depend on it:\n'
+                f'{", ".join(dependent_store_names)}'
+            )
+
+        self._tbl_version.drop_column(col)
 
     def rename_column(self, old_name: str, new_name: str) -> None:
         """Rename a column.
@@ -522,15 +560,15 @@ class Table(SchemaObject):
 
     def add_embedding_index(
             self, col_name: str, *, idx_name: Optional[str] = None,
-            text_embed: Optional[pixeltable.Function] = None, img_embed: Optional[pixeltable.Function] = None,
+            string_embed: Optional[pixeltable.Function] = None, image_embed: Optional[pixeltable.Function] = None,
             metric: str = 'cosine'
     ) -> None:
         """Add an index to the table.
         Args:
             col_name: name of column to index
             idx_name: name of index, which needs to be unique for the table; if not provided, a name will be generated
-            text_embed: function to embed text; required if the column is a text column
-            img_embed: function to embed images; required if the column is an image column
+            string_embed: function to embed text; required if the column is a text column
+            image_embed: function to embed images; required if the column is an image column
             metric: distance metric to use for the index; one of 'cosine', 'ip', 'l2'; default is 'cosine'
 
         Raises:
@@ -539,13 +577,13 @@ class Table(SchemaObject):
         Examples:
             Add an index to the ``img`` column:
 
-            >>> tbl.add_embedding_index('img', img_embed=...)
+            >>> tbl.add_embedding_index('img', image_embed=...)
 
             Add another index to the ``img`` column, using the inner product as the distance metric,
-            and with a specific name; ``text_embed`` is also specified in order to search with text:
+            and with a specific name; ``string_embed`` is also specified in order to search with text:
 
             >>> tbl.add_embedding_index(
-                'img', idx_name='clip_idx', img_embed=..., text_embed=...text_embed..., metric='ip')
+                'img', idx_name='clip_idx', image_embed=..., string_embed=..., metric='ip')
         """
         if self._tbl_version_path.is_snapshot():
             raise excs.Error('Cannot add an index to a snapshot')
@@ -557,7 +595,7 @@ class Table(SchemaObject):
             raise excs.Error(f'Duplicate index name: {idx_name}')
         from pixeltable.index import EmbeddingIndex
         # create the EmbeddingIndex instance to verify args
-        idx = EmbeddingIndex(col, metric=metric, text_embed=text_embed, img_embed=img_embed)
+        idx = EmbeddingIndex(col, metric=metric, string_embed=string_embed, image_embed=image_embed)
         status = self._tbl_version.add_index(col, idx_name=idx_name, idx=idx)
         # TODO: how to deal with exceptions here? drop the index and raise?
 
@@ -604,26 +642,26 @@ class Table(SchemaObject):
             raise excs.Error('Cannot drop an index from a snapshot')
         self._check_is_dropped()
         if (column_name is None) == (idx_name is None):
-            raise excs.Error('Exactly one of column_name or idx_name must be provided')
+            raise excs.Error("Exactly one of 'column_name' or 'idx_name' must be provided")
 
         if idx_name is not None:
             if idx_name not in self._tbl_version.idxs_by_name:
-                raise excs.Error(f'Index {idx_name} does not exist')
+                raise excs.Error(f'Index {idx_name!r} does not exist')
             idx_id = self._tbl_version.idxs_by_name[idx_name].id
         else:
             col = self._tbl_version_path.get_column(column_name, include_bases=True)
             if col is None:
-                raise excs.Error(f'Column {column_name} unknown')
+                raise excs.Error(f'Column {column_name!r} unknown')
             if col.tbl.id != self._tbl_version.id:
                 raise excs.Error(
-                    f'Column {column_name}: cannot drop index from column that belongs to base ({col.tbl.name})')
+                    f'Column {column_name!r}: cannot drop index from column that belongs to base ({col.tbl.name}!r)')
             idx_info = [info for info in self._tbl_version.idxs_by_name.values() if info.col.id == col.id]
             if _idx_class is not None:
                 idx_info = [info for info in idx_info if isinstance(info.idx, _idx_class)]
             if len(idx_info) == 0:
-                raise excs.Error(f'Column {column_name} does not have an index')
+                raise excs.Error(f'Column {column_name!r} does not have an index')
             if len(idx_info) > 1:
-                raise excs.Error(f'Column {column_name} has multiple indices; specify idx_name instead')
+                raise excs.Error(f"Column {column_name!r} has multiple indices; specify 'idx_name' instead")
             idx_id = idx_info[0].id
         self._tbl_version.drop_index(idx_id)
 
@@ -678,13 +716,13 @@ class Table(SchemaObject):
         raise NotImplementedError
 
     def update(
-            self, value_spec: dict[str, Any], where: Optional['pixeltable.exprs.Predicate'] = None, cascade: bool = True
+            self, value_spec: dict[str, Any], where: Optional['pixeltable.exprs.Expr'] = None, cascade: bool = True
     ) -> UpdateStatus:
         """Update rows in this table.
 
         Args:
             value_spec: a dictionary mapping column names to literal values or Pixeltable expressions.
-            where: a Predicate to filter rows to update.
+            where: a predicate to filter rows to update.
             cascade: if True, also update all computed columns that transitively depend on the updated columns.
 
         Examples:
@@ -748,11 +786,11 @@ class Table(SchemaObject):
             row_updates.append(col_vals)
         return self._tbl_version.batch_update(row_updates, rowids, cascade)
 
-    def delete(self, where: Optional['pixeltable.exprs.Predicate'] = None) -> UpdateStatus:
+    def delete(self, where: Optional['pixeltable.exprs.Expr'] = None) -> UpdateStatus:
         """Delete rows in this table.
 
         Args:
-            where: a Predicate to filter rows to delete.
+            where: a predicate to filter rows to delete.
 
         Examples:
             Delete all rows in a table:
@@ -823,13 +861,13 @@ class Table(SchemaObject):
         Links the specified `ExternalStore` to this table.
         """
         if self._tbl_version.is_snapshot:
-            raise excs.Error(f'Table `{self.get_name()}` is a snapshot, so it cannot be linked to an external store.')
+            raise excs.Error(f'Table `{self.name}` is a snapshot, so it cannot be linked to an external store.')
         self._check_is_dropped()
         if store.name in self.external_stores:
-            raise excs.Error(f'Table `{self.get_name()}` already has an external store with that name: {store.name}')
-        _logger.info(f'Linking external store `{store.name}` to table `{self.get_name()}`')
+            raise excs.Error(f'Table `{self.name}` already has an external store with that name: {store.name}')
+        _logger.info(f'Linking external store `{store.name}` to table `{self.name}`')
         self._tbl_version.link_external_store(store)
-        print(f'Linked external store `{store.name}` to table `{self.get_name()}`.')
+        print(f'Linked external store `{store.name}` to table `{self.name}`.')
 
     def unlink_external_stores(
             self,
@@ -861,11 +899,11 @@ class Table(SchemaObject):
         if not ignore_errors:
             for store in stores:
                 if store not in all_stores:
-                    raise excs.Error(f'Table `{self.get_name()}` has no external store with that name: {store}')
+                    raise excs.Error(f'Table `{self.name}` has no external store with that name: {store}')
 
         for store in stores:
             self._tbl_version.unlink_external_store(store, delete_external_data=delete_external_data)
-            print(f'Unlinked external store from table `{self.get_name()}`: {store}')
+            print(f'Unlinked external store from table `{self.name}`: {store}')
 
     def sync(
             self,
@@ -893,7 +931,7 @@ class Table(SchemaObject):
 
         for store in stores:
             if store not in all_stores:
-                raise excs.Error(f'Table `{self.get_name()}` has no external store with that name: {store}')
+                raise excs.Error(f'Table `{self.name}` has no external store with that name: {store}')
 
         from pixeltable.io import SyncStatus
 

pixeltable/catalog/table_version.py

@@ -540,39 +540,12 @@ class TableVersion:
             num_rows=row_count, num_computed_values=row_count, num_excs=num_excs,
             cols_with_excs=[f'{col.tbl.name}.{col.name}'for col in cols_with_excs if col.name is not None])
 
-    def drop_column(self, name: str) -> None:
+    def drop_column(self, col: Column) -> None:
         """Drop a column from the table.
         """
         from pixeltable.catalog import Catalog
 
         assert not self.is_snapshot
-        if name not in self.cols_by_name:
-            raise excs.Error(f'Unknown column: {name}')
-        col = self.cols_by_name[name]
-        dependent_user_cols = [c for c in col.dependent_cols if c.name is not None]
-        if len(dependent_user_cols) > 0:
-            raise excs.Error(
-                f'Cannot drop column `{name}` because the following columns depend on it:\n'
-                f'{", ".join(c.name for c in dependent_user_cols)}'
-            )
-        # See if this column has a dependent store. We need to look through all stores in all
-        # (transitive) views of this table.
-        transitive_views = Catalog.get().tbls[self.id].get_views(recursive=True)
-        dependent_stores = [
-            (view, store)
-            for view in transitive_views
-            for store in view._tbl_version.external_stores.values()
-            if col in store.get_local_columns()
-        ]
-        if len(dependent_stores) > 0:
-            dependent_store_names = [
-                store.name if view._get_id() == self.id else f'{store.name} (in view `{view.get_name()}`)'
-                for view, store in dependent_stores
-            ]
-            raise excs.Error(
-                f'Cannot drop column `{name}` because the following external stores depend on it:\n'
-                f'{", ".join(dependent_store_names)}'
-            )
 
         # we're creating a new schema version
         self.version += 1
@@ -596,7 +569,7 @@ class TableVersion:
                 del self.idxs_by_name[idx_name]
             self._drop_columns(dropped_cols)
             self._update_md(time.time(), conn, preceding_schema_version=preceding_schema_version)
-        _logger.info(f'Dropped column {name} from table {self.name}, new version: {self.version}')
+        _logger.info(f'Dropped column {col.name} from table {self.name}, new version: {self.version}')
 
     def _drop_columns(self, cols: Iterable[Column]) -> None:
         """Mark columns as dropped"""
@@ -705,12 +678,12 @@ class TableVersion:
         return result
 
     def update(
-        self, value_spec: dict[str, Any], where: Optional['exprs.Predicate'] = None, cascade: bool = True
+        self, value_spec: dict[str, Any], where: Optional['exprs.Expr'] = None, cascade: bool = True
     ) -> UpdateStatus:
         """Update rows in this TableVersionPath.
         Args:
             value_spec: a list of (column, value) pairs specifying the columns to update and their new values.
-            where: a Predicate to filter rows to update.
+            where: a predicate to filter rows to update.
             cascade: if True, also update all computed columns that transitively depend on the updated columns,
                 including within views.
         """
@@ -721,8 +694,8 @@ class TableVersion:
 
         update_spec = self._validate_update_spec(value_spec, allow_pk=False, allow_exprs=True)
         if where is not None:
-            if not isinstance(where, exprs.Predicate):
-                raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
+            if not isinstance(where, exprs.Expr):
+                raise excs.Error(f"'where' argument must be a predicate, got {type(where)}")
             analysis_info = Planner.analyze(self.path, where)
             # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
             if analysis_info.filter is not None:
@@ -784,7 +757,7 @@ class TableVersion:
 
     def _update(
             self, conn: sql.engine.Connection, update_targets: dict[Column, 'pixeltable.exprs.Expr'],
-            where_clause: Optional['pixeltable.exprs.Predicate'] = None, cascade: bool = True,
+            where_clause: Optional['pixeltable.exprs.Expr'] = None, cascade: bool = True,
             show_progress: bool = True
     ) -> UpdateStatus:
         from pixeltable.plan import Planner
@@ -816,8 +789,6 @@ class TableVersion:
                 raise excs.Error(f'Column {col_name} is computed and cannot be updated')
             if col.is_pk and not allow_pk:
                 raise excs.Error(f'Column {col_name} is a primary key column and cannot be updated')
-            if col.col_type.is_media_type():
-                raise excs.Error(f'Column {col_name} has type image/video/audio/document and cannot be updated')
 
             # make sure that the value is compatible with the column type
             try:
@@ -875,17 +846,17 @@ class TableVersion:
         result.cols_with_excs = list(dict.fromkeys(result.cols_with_excs).keys())  # remove duplicates
         return result
 
-    def delete(self, where: Optional['exprs.Predicate'] = None) -> UpdateStatus:
+    def delete(self, where: Optional['exprs.Expr'] = None) -> UpdateStatus:
         """Delete rows in this table.
         Args:
-            where: a Predicate to filter rows to delete.
+            where: a predicate to filter rows to delete.
         """
         assert self.is_insertable()
-        from pixeltable.exprs import Predicate
+        from pixeltable.exprs import Expr
         from pixeltable.plan import Planner
         if where is not None:
-            if not isinstance(where, Predicate):
-                raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
+            if not isinstance(where, Expr):
+                raise excs.Error(f"'where' argument must be a predicate, got {type(where)}")
             analysis_info = Planner.analyze(self.path, where)
             # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
             if analysis_info.filter is not None:
@@ -899,11 +870,11 @@ class TableVersion:
         return status
 
     def propagate_delete(
-            self, where: Optional['exprs.Predicate'], base_versions: List[Optional[int]],
+            self, where: Optional['exprs.Expr'], base_versions: List[Optional[int]],
             conn: sql.engine.Connection, timestamp: float) -> int:
         """Delete rows in this table and propagate to views.
         Args:
-            where: a Predicate to filter rows to delete.
+            where: a predicate to filter rows to delete.
         Returns:
             number of deleted rows
         """

pixeltable/catalog/view.py

@@ -51,7 +51,7 @@ class View(Table):
     @classmethod
     def create(
             cls, dir_id: UUID, name: str, base: TableVersionPath, schema: Dict[str, Any],
-            predicate: 'pxt.exprs.Predicate', is_snapshot: bool, num_retained_versions: int, comment: str,
+            predicate: 'pxt.exprs.Expr', is_snapshot: bool, num_retained_versions: int, comment: str,
             iterator_cls: Optional[Type[ComponentIterator]], iterator_args: Optional[Dict]
     ) -> View:
         columns = cls._create_columns(schema)
@@ -213,5 +213,5 @@ class View(Table):
     ) -> UpdateStatus:
         raise excs.Error(f'{self.display_name()} {self._name!r}: cannot insert into view')
 
-    def delete(self, where: Optional['pixeltable.exprs.Predicate'] = None) -> UpdateStatus:
+    def delete(self, where: Optional['pixeltable.exprs.Expr'] = None) -> UpdateStatus:
         raise excs.Error(f'{self.display_name()} {self._name!r}: cannot delete from view')

pixeltable/dataframe.py

@@ -153,7 +153,7 @@ class DataFrame:
         self,
         tbl: catalog.TableVersionPath,
         select_list: Optional[List[Tuple[exprs.Expr, Optional[str]]]] = None,
-        where_clause: Optional[exprs.Predicate] = None,
+        where_clause: Optional[exprs.Expr] = None,
         group_by_clause: Optional[List[exprs.Expr]] = None,
         grouping_tbl: Optional[catalog.TableVersion] = None,
         order_by_clause: Optional[List[Tuple[exprs.Expr, bool]]] = None,  # List[(expr, asc)]
@@ -530,7 +530,11 @@ class DataFrame:
             limit=self.limit_val,
         )
 
-    def where(self, pred: exprs.Predicate) -> DataFrame:
+    def where(self, pred: exprs.Expr) -> DataFrame:
+        if not isinstance(pred, exprs.Expr):
+            raise excs.Error(f'Where() requires a Pixeltable expression, but instead got {type(pred)}')
+        if not pred.col_type.is_bool_type():
+            raise excs.Error(f'Where(): expression needs to return bool, but instead returns {pred.col_type}')
         return DataFrame(
             self.tbl,
             select_list=self.select_list,
@@ -558,7 +562,7 @@ class DataFrame:
                 # we need to make sure that the grouping table is a base of self.tbl
                 base = self.tbl.find_tbl_version(item._tbl_version_path.tbl_id())
                 if base is None or base.id == self.tbl.tbl_id():
-                    raise excs.Error(f'group_by(): {item.get_name()} is not a base table of {self.tbl.tbl_name()}')
+                    raise excs.Error(f'group_by(): {item.name} is not a base table of {self.tbl.tbl_name()}')
                 grouping_tbl = item._tbl_version_path.tbl_version
                 break
             if not isinstance(item, exprs.Expr):
@@ -628,12 +632,9 @@ class DataFrame:
     def __getitem__(self, index: object) -> DataFrame:
         """
         Allowed:
-        - [<Predicate>]: filter operation
         - [List[Expr]]/[Tuple[Expr]]: setting the select list
         - [Expr]: setting a single-col select list
         """
-        if isinstance(index, exprs.Predicate):
-            return self.where(index)
         if isinstance(index, tuple):
             index = list(index)
         if isinstance(index, exprs.Expr):
@@ -668,7 +669,7 @@ class DataFrame:
         tbl = catalog.TableVersionPath.from_dict(d['tbl'])
         select_list = [(exprs.Expr.from_dict(e), name) for e, name in d['select_list']] \
             if d['select_list'] is not None else None
-        where_clause = exprs.Predicate.from_dict(d['where_clause']) \
+        where_clause = exprs.Expr.from_dict(d['where_clause']) \
             if d['where_clause'] is not None else None
         group_by_clause = [exprs.Expr.from_dict(e) for e in d['group_by_clause']] \
             if d['group_by_clause'] is not None else None

pixeltable/exec/expr_eval_node.py

@@ -50,7 +50,14 @@ class ExprEvalNode(ExecNode):
 
     def _open(self) -> None:
         warnings.simplefilter("ignore", category=TqdmWarning)
-        if self.ctx.show_pbar:
+        # This is a temporary hack. When B-tree indices on string columns were implemented (via computed columns
+        # that invoke the `BtreeIndex.str_filter` udf), it resulted in frivolous progress bars appearing on every
+        # insertion. This special-cases the `str_filter` call to suppress the corresponding progress bar.
+        # TODO(aaron-siegel) Remove this hack once we clean up progress bars more generally.
+        is_str_filter_node = all(
+            isinstance(expr, exprs.FunctionCall) and expr.fn.name == 'str_filter' for expr in self.output_exprs
+        )
+        if self.ctx.show_pbar and not is_str_filter_node:
             self.pbar = tqdm(
                 total=len(self.target_exprs) * self.ctx.num_rows,
                 desc='Computing cells',

pixeltable/exec/sql_scan_node.py

@@ -19,7 +19,7 @@ class SqlScanNode(ExecNode):
     def __init__(
             self, tbl: catalog.TableVersionPath, row_builder: exprs.RowBuilder,
             select_list: Iterable[exprs.Expr],
-            where_clause: Optional[exprs.Expr] = None, filter: Optional[exprs.Predicate] = None,
+            where_clause: Optional[exprs.Expr] = None, filter: Optional[exprs.Expr] = None,
             order_by_items: Optional[List[Tuple[exprs.Expr, bool]]] = None,
             limit: int = 0, set_pk: bool = False, exact_version_only: Optional[List[catalog.TableVersion]] = None
     ):

pixeltable/exprs/__init__.py

@@ -17,7 +17,6 @@ from .json_mapper import JsonMapper
 from .json_path import RELATIVE_PATH_ROOT, JsonPath
 from .literal import Literal
 from .object_ref import ObjectRef
-from .predicate import Predicate
 from .row_builder import RowBuilder, ColumnSlotIdx, ExecProfile
 from .rowid_ref import RowidRef
 from .similarity_expr import SimilarityExpr

pixeltable/exprs/column_ref.py

@@ -63,14 +63,9 @@ class ColumnRef(Expr):
 
         return super().__getattr__(name)
 
-    def similarity(self, other: Any) -> Expr:
-        # if isinstance(other, Expr):
-        #     raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
-        item = Expr.from_object(other)
-        if item is None or not(item.col_type.is_string_type() or item.col_type.is_image_type()):
-            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not a {type(other)}')
+    def similarity(self, item: Any, *, idx: Optional[str] = None) -> Expr:
         from .similarity_expr import SimilarityExpr
-        return SimilarityExpr(self, item)
+        return SimilarityExpr(self, item, idx_name=idx)
 
     def default_column_name(self) -> Optional[str]:
         return str(self)

pixeltable/exprs/comparison.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, List, Any, Dict, Tuple
+from typing import Optional, List, Any, Dict
 
 import sqlalchemy as sql
 
@@ -9,15 +9,15 @@ from .data_row import DataRow
 from .expr import Expr
 from .globals import ComparisonOperator
 from .literal import Literal
-from .predicate import Predicate
 from .row_builder import RowBuilder
 import pixeltable.exceptions as excs
 import pixeltable.index as index
+import pixeltable.type_system as ts
 
 
-class Comparison(Predicate):
+class Comparison(Expr):
     def __init__(self, operator: ComparisonOperator, op1: Expr, op2: Expr):
-        super().__init__()
+        super().__init__(ts.BoolType())
         self.operator = operator
 
         # if this is a comparison of a column to a literal (ie, could be used as a search argument in an index lookup),
@@ -50,7 +50,7 @@ class Comparison(Predicate):
     def _equals(self, other: Comparison) -> bool:
         return self.operator == other.operator
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('operator', self.operator.value)]
 
     @property

pixeltable/exprs/compound_predicate.py

@@ -1,20 +1,20 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple, Callable
+
 import operator
+from typing import Optional, List, Any, Dict, Callable
 
 import sqlalchemy as sql
 
+from .data_row import DataRow
 from .expr import Expr
 from .globals import LogicalOperator
-from .predicate import Predicate
-from .data_row import DataRow
 from .row_builder import RowBuilder
-import pixeltable.catalog as catalog
+import pixeltable.type_system as ts
 
 
-class CompoundPredicate(Predicate):
-    def __init__(self, operator: LogicalOperator, operands: List[Predicate]):
-        super().__init__()
+class CompoundPredicate(Expr):
+    def __init__(self, operator: LogicalOperator, operands: List[Expr]):
+        super().__init__(ts.BoolType())
         self.operator = operator
         # operands are stored in self.components
         if self.operator == LogicalOperator.NOT:
@@ -22,7 +22,7 @@ class CompoundPredicate(Predicate):
             self.components = operands
         else:
             assert len(operands) > 1
-            self.operands: List[Predicate] = []
+            self.operands: List[Expr] = []
             for operand in operands:
                 self._merge_operand(operand)
 
@@ -34,14 +34,14 @@ class CompoundPredicate(Predicate):
         return f' {self.operator} '.join([f'({e})' for e in self.components])
 
     @classmethod
-    def make_conjunction(cls, operands: List[Predicate]) -> Optional[Predicate]:
+    def make_conjunction(cls, operands: List[Expr]) -> Optional[Expr]:
         if len(operands) == 0:
             return None
         if len(operands) == 1:
             return operands[0]
         return CompoundPredicate(LogicalOperator.AND, operands)
 
-    def _merge_operand(self, operand: Predicate) -> None:
+    def _merge_operand(self, operand: Expr) -> None:
         """
         Merge this operand, if possible, otherwise simply record it.
         """
@@ -55,11 +55,11 @@ class CompoundPredicate(Predicate):
     def _equals(self, other: CompoundPredicate) -> bool:
         return self.operator == other.operator
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('operator', self.operator.value)]
 
     def split_conjuncts(
-            self, condition: Callable[[Predicate], bool]) -> Tuple[List[Predicate], Optional[Predicate]]:
+            self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
         if self.operator == LogicalOperator.OR or self.operator == LogicalOperator.NOT:
             return super().split_conjuncts(condition)
         matches = [op for op in self.components if condition(op)]