pixeltable 0.2.21__py3-none-any.whl → 0.2.23__py3-none-any.whl

pixeltable/exprs/json_path.py

@@ -5,28 +5,23 @@ from typing import Any, Optional, Union
 import jmespath
 import sqlalchemy as sql
 
-import pixeltable
+import pixeltable as pxt
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
-from .data_row import DataRow
-from .expr import Expr
-from .globals import print_slice
-from .json_mapper import JsonMapper
-from .row_builder import RowBuilder
-from .sql_element_cache import SqlElementCache
 
 from .data_row import DataRow
 from .expr import Expr
 from .globals import print_slice
 from .json_mapper import JsonMapper
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 
 class JsonPath(Expr):
     def __init__(
         self,
-        anchor: Optional['pixeltable.exprs.ColumnRef'],
+        anchor: Optional['pxt.exprs.Expr'],
         path_elements: Optional[list[Union[str, int, slice]]] = None,
         scope_idx: int = 0
     ) -> None:
@@ -37,7 +32,7 @@ class JsonPath(Expr):
         """
         if path_elements is None:
             path_elements = []
-        super().__init__(ts.JsonType())
+        super().__init__(ts.JsonType(nullable=True))  # JsonPath expressions are always nullable
         if anchor is not None:
             self.components = [anchor]
         self.path_elements: list[Union[str, int, slice]] = path_elements
@@ -61,7 +56,7 @@ class JsonPath(Expr):
         return {'path_elements': path_elements, 'scope_idx': self.scope_idx, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: dict, components: list[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> JsonPath:
         assert 'path_elements' in d
         assert 'scope_idx' in d
         assert len(components) <= 1
@@ -143,7 +138,7 @@ class JsonPath(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('path_elements', self.path_elements)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         """
         Postgres appears to have a bug: jsonb_path_query('{a: [{b: 0}, {b: 1}]}', '$.a.b') returns
         *two* rows (each containing col val 0), not a single row with [0, 0].

pixeltable/exprs/literal.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import datetime
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
@@ -54,10 +54,10 @@ class Literal(Expr):
     def _equals(self, other: Literal) -> bool:
         return self.val == other.val
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('val', self.val)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         # we need to return something here so that we can generate a Where clause for predicates
         # that involve literals (like Where c > 0)
         return sql.sql.expression.literal(self.val)
@@ -66,7 +66,7 @@ class Literal(Expr):
         # this will be called, even though sql_expr() does not return None
         data_row[self.slot_idx] = self.val
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         # For some types, we need to explictly record their type, because JSON does not know
         # how to interpret them unambiguously
         if self.col_type.is_timestamp_type():
@@ -80,7 +80,7 @@ class Literal(Expr):
             return {'val': self.val, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> Literal:
         assert 'val' in d
         if 'val_t' in d:
             val_t = d['val_t']

pixeltable/exprs/method_ref.py

@@ -5,6 +5,7 @@ import sqlalchemy as sql
 import pixeltable.type_system as ts
 from pixeltable.exprs import Expr, FunctionCall
 from pixeltable.func import FunctionRegistry
+
 from .data_row import DataRow
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
@@ -36,10 +37,10 @@ class MethodRef(Expr):
         return {'method_name': self.method_name, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: dict, components: list[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> 'MethodRef':
         assert 'method_name' in d
         assert len(components) == 1
-        return cls(d['method_name'], components[0])
+        return cls(components[0], d['method_name'])
 
     def __call__(self, *args, **kwargs) -> FunctionCall:
         result = self.fn(*[self.base_expr, *args], **kwargs)
@@ -48,12 +49,12 @@ class MethodRef(Expr):
         return result
 
     def _equals(self, other: 'MethodRef') -> bool:
-        return self.base_expr == other.base_expr and self.method_name == other.method_name
+        return self.base_expr.id == other.base_expr.id and self.method_name == other.method_name
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('method_name', self.method_name)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/object_ref.py

@@ -5,6 +5,7 @@ from typing import Optional
 import sqlalchemy as sql
 
 import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr, ExprScope
 from .json_mapper import JsonMapper
@@ -33,7 +34,7 @@ class ObjectRef(Expr):
     def _equals(self, other: ObjectRef) -> bool:
         return self.owner is other.owner
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/row_builder.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 import sys
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Tuple
+from typing import Any, Iterable, Optional, Sequence
+from uuid import UUID
 
 import sqlalchemy as sql
 
@@ -11,7 +12,6 @@ import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.func as func
 import pixeltable.utils as utils
-
 from .data_row import DataRow
 from .expr import Expr
 from .expr_set import ExprSet
@@ -48,14 +48,37 @@ class RowBuilder:
     For ColumnRefs to unstored iterator columns:
     - in order for them to be executable, we also record the iterator args and pass them to the ColumnRef
     """
+    unique_exprs: ExprSet
+    next_slot_idx: int
+    input_expr_slot_idxs: set[int]
+
+    # output exprs: all exprs the caller wants to materialize
+    # - explicitly requested output_exprs
+    # - values for computed columns
+    output_exprs: ExprSet
+
+    input_exprs: ExprSet
+
+    table_columns: list[ColumnSlotIdx]
+    default_eval_ctx: EvalCtx
+    unstored_iter_args: dict[UUID, Expr]
+
+    # transitive dependents for the purpose of exception propagation: an exception for slot i is propagated to
+    # _exc_dependents[i]
+    # (list of set of slot_idxs, indexed by slot_idx)
+    _exc_dependents: list[set[int]]
+
+    # records the output_expr that a subexpr belongs to
+    # (a subexpr can be shared across multiple output exprs)
+    output_expr_ids: list[set[int]]
 
     @dataclass
     class EvalCtx:
         """Context for evaluating a set of target exprs"""
-        slot_idxs: List[int]  # slot idxs of exprs needed to evaluate target exprs; does not contain duplicates
-        exprs: List[Expr]  # exprs corresponding to slot_idxs
-        target_slot_idxs: List[int]  # slot idxs of target exprs; might contain duplicates
-        target_exprs: List[Expr]  # exprs corresponding to target_slot_idxs
+        slot_idxs: list[int]  # slot idxs of exprs needed to evaluate target exprs; does not contain duplicates
+        exprs: list[Expr]  # exprs corresponding to slot_idxs
+        target_slot_idxs: list[int]  # slot idxs of target exprs; might contain duplicates
+        target_exprs: list[Expr]  # exprs corresponding to target_slot_idxs
 
     def __init__(
             self, output_exprs: Sequence[Expr], columns: Sequence[catalog.Column], input_exprs: Iterable[Expr]
@@ -67,35 +90,56 @@ class RowBuilder:
             input_exprs: list of Exprs that are excluded from evaluation (because they're already materialized)
         TODO: enforce that output_exprs doesn't overlap with input_exprs?
         """
-        self.unique_exprs = ExprSet()  # dependencies precede their dependents
+        self.unique_exprs: ExprSet[Expr] = ExprSet()  # dependencies precede their dependents
         self.next_slot_idx = 0
 
         # record input and output exprs; make copies to avoid reusing execution state
         unique_input_exprs = [self._record_unique_expr(e.copy(), recursive=False) for e in input_exprs]
         self.input_expr_slot_idxs = {e.slot_idx for e in unique_input_exprs}
 
-        # output exprs: all exprs the caller wants to materialize
-        # - explicitly requested output_exprs
-        # - values for computed columns
         resolve_cols = set(columns)
         self.output_exprs = ExprSet([
             self._record_unique_expr(e.copy().resolve_computed_cols(resolve_cols=resolve_cols), recursive=True)
             for e in output_exprs
         ])
 
-        # record columns for create_table_row()
+        # if init(columns):
+        # - we are creating table rows and need to record columns for create_table_row()
+        # - output_exprs materialize those columns
+        # - input_exprs are ColumnRefs of the non-computed columns (ie, what needs to be provided as input)
+        # - media validation:
+        #   * for write-validated columns, we need to create validating ColumnRefs
+        #   * further references to that column (eg, computed cols) need to resolve to the validating ColumnRef
         from .column_ref import ColumnRef
-        self.table_columns: List[ColumnSlotIdx] = []
+        self.table_columns: list[ColumnSlotIdx] = []
+        self.input_exprs = ExprSet()
+        validating_colrefs: dict[Expr, Expr] = {}  # key: non-validating colref, value: corresp. validating colref
         for col in columns:
+            expr: Expr
             if col.is_computed:
                 assert col.value_expr is not None
                 # create a copy here so we don't reuse execution state and resolve references to computed columns
                 expr = col.value_expr.copy().resolve_computed_cols(resolve_cols=resolve_cols)
+                expr = expr.substitute(validating_colrefs)
                 expr = self._record_unique_expr(expr, recursive=True)
             else:
                 # record a ColumnRef so that references to this column resolve to the same slot idx
-                expr = ColumnRef(col)
-                expr = self._record_unique_expr(expr, recursive=False)
+                perform_validation = (
+                    None if not col.col_type.is_media_type()
+                    else col.media_validation == catalog.MediaValidation.ON_WRITE
+                )
+                expr = ColumnRef(col, perform_validation=perform_validation)
+                # recursive=True: needed for validating ColumnRef
+                expr = self._record_unique_expr(expr, recursive=True)
+
+                if perform_validation:
+                    # if expr is a validating ColumnRef, the input is the non-validating ColumnRef
+                    non_validating_colref = expr.components[0]
+                    self.input_exprs.add(non_validating_colref)
+                    validating_colrefs[non_validating_colref] = expr
+                else:
+                    self.input_exprs.add(expr)
+
             self.add_table_column(col, expr.slot_idx)
             self.output_exprs.add(expr)
 
@@ -118,8 +162,9 @@ class RowBuilder:
         unstored_iter_col_refs = [col_ref for col_ref in col_refs if refs_unstored_iter_col(col_ref)]
         component_views = [col_ref.col.tbl for col_ref in unstored_iter_col_refs]
         unstored_iter_args = {view.id: view.iterator_args.copy() for view in component_views}
-        self.unstored_iter_args = \
-            {id: self._record_unique_expr(arg, recursive=True) for id, arg in unstored_iter_args.items()}
+        self.unstored_iter_args = {
+            id: self._record_unique_expr(arg, recursive=True) for id, arg in unstored_iter_args.items()
+        }
 
         for col_ref in unstored_iter_col_refs:
             iter_arg_ctx = self.create_eval_ctx([unstored_iter_args[col_ref.col.tbl.id]])
@@ -129,25 +174,28 @@ class RowBuilder:
         for i, expr in enumerate(self.unique_exprs):
             assert expr.slot_idx == i
 
-        # record transitive dependencies (list of set of slot_idxs, indexed by slot_idx)
-        self.dependencies: List[Set[int]] = [set() for _ in range(self.num_materialized)]
+        # determine transitive dependencies for the purpose of exception propagation
+        # (list of set of slot_idxs, indexed by slot_idx)
+        exc_dependencies: list[set[int]] = [set() for _ in range(self.num_materialized)]
+        from .column_property_ref import ColumnPropertyRef
         for expr in self.unique_exprs:
             if expr.slot_idx in self.input_expr_slot_idxs:
                 # this is input and therefore doesn't depend on other exprs
                 continue
+            # error properties don't have exceptions themselves
+            if isinstance(expr, ColumnPropertyRef) and expr.is_error_prop():
+                continue
             for d in expr.dependencies():
-                self.dependencies[expr.slot_idx].add(d.slot_idx)
-                self.dependencies[expr.slot_idx].update(self.dependencies[d.slot_idx])
+                exc_dependencies[expr.slot_idx].add(d.slot_idx)
+                exc_dependencies[expr.slot_idx].update(exc_dependencies[d.slot_idx])
 
-        # derive transitive dependents
-        self.dependents: List[Set[int]] = [set() for _ in range(self.num_materialized)]
+        self._exc_dependents = [set() for _ in range(self.num_materialized)]
         for expr in self.unique_exprs:
-            for d in self.dependencies[expr.slot_idx]:
-                self.dependents[d].add(expr.slot_idx)
+            assert expr.slot_idx is not None
+            for d_idx in exc_dependencies[expr.slot_idx]:
+                self._exc_dependents[d_idx].add(expr.slot_idx)
 
-        # records the output_expr that a subexpr belongs to
-        # (a subexpr can be shared across multiple output exprs)
-        self.output_expr_ids: List[Set[int]] = [set() for _ in range(self.num_materialized)]
+        self.output_expr_ids = [set() for _ in range(self.num_materialized)]
         for e in self.output_exprs:
             self._record_output_expr_id(e, e.slot_idx)
 
@@ -155,7 +203,7 @@ class RowBuilder:
         """Record a column that is part of the table row"""
         self.table_columns.append(ColumnSlotIdx(col, slot_idx))
 
-    def output_slot_idxs(self) -> List[ColumnSlotIdx]:
+    def output_slot_idxs(self) -> list[ColumnSlotIdx]:
         """Return ColumnSlotIdx for output columns"""
         return self.table_columns
 
@@ -206,9 +254,9 @@ class RowBuilder:
         for d in e.dependencies():
             self._record_output_expr_id(d, output_expr_id)
 
-    def _compute_dependencies(self, target_slot_idxs: List[int], excluded_slot_idxs: List[int]) -> List[int]:
+    def _compute_dependencies(self, target_slot_idxs: list[int], excluded_slot_idxs: list[int]) -> list[int]:
         """Compute exprs needed to materialize the given target slots, excluding 'excluded_slot_idxs'"""
-        dependencies = [set() for _ in range(self.num_materialized)]  # indexed by slot_idx
+        dependencies: list[set[int]] = [set() for _ in range(self.num_materialized)]  # indexed by slot_idx
         # doing this front-to-back ensures that we capture transitive dependencies
         max_target_slot_idx = max(target_slot_idxs)
         for expr in self.unique_exprs:
@@ -237,6 +285,8 @@ class RowBuilder:
         for e in expr_list:
             self.__set_slot_idxs_aux(e)
         if remove_duplicates:
+            # only allowed if `expr_list` is a mutable list
+            assert isinstance(expr_list, list)
             deduped = list(ExprSet(expr_list))
             expr_list[:] = deduped
 
@@ -248,13 +298,14 @@ class RowBuilder:
         for c in e.components:
             self.__set_slot_idxs_aux(c)
 
-    def get_dependencies(self, targets: List[Expr], exclude: Optional[List[Expr]] = None) -> List[Expr]:
+    def get_dependencies(self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None) -> list[Expr]:
         """
         Return list of dependencies needed to evaluate the given target exprs (expressed as slot idxs).
         The exprs given in 'exclude' are excluded.
         Returns:
             list of Exprs from unique_exprs (= with slot_idx set)
         """
+        targets = list(targets)
         if exclude is None:
             exclude = []
         if len(targets) == 0:
@@ -270,8 +321,9 @@ class RowBuilder:
         result_ids.sort()
         return [self.unique_exprs[id] for id in result_ids]
 
-    def create_eval_ctx(self, targets: list[Expr], exclude: Optional[list[Expr]] = None) -> EvalCtx:
+    def create_eval_ctx(self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None) -> EvalCtx:
         """Return EvalCtx for targets"""
+        targets = list(targets)
         if exclude is None:
             exclude = []
         if len(targets) == 0:
@@ -287,7 +339,7 @@ class RowBuilder:
     def set_exc(self, data_row: DataRow, slot_idx: int, exc: Exception) -> None:
         """Record an exception in data_row and propagate it to dependents"""
         data_row.set_exc(slot_idx, exc)
-        for slot_idx in self.dependents[slot_idx]:
+        for slot_idx in self._exc_dependents[slot_idx]:
             data_row.set_exc(slot_idx, exc)
 
     def eval(
@@ -318,14 +370,14 @@ class RowBuilder:
                     raise excs.ExprEvalError(
                         expr, f'expression {expr}', data_row.get_exc(expr.slot_idx), exc_tb, input_vals, 0)
 
-    def create_table_row(self, data_row: DataRow, exc_col_ids: Set[int]) -> Tuple[Dict[str, Any], int]:
+    def create_table_row(self, data_row: DataRow, exc_col_ids: set[int]) -> tuple[dict[str, Any], int]:
         """Create a table row from the slots that have an output column assigned
 
-        Return Tuple[dict that represents a stored row (can be passed to sql.insert()), # of exceptions]
+        Return tuple[dict that represents a stored row (can be passed to sql.insert()), # of exceptions]
             This excludes system columns.
         """
         num_excs = 0
-        table_row: Dict[str, Any] = {}
+        table_row: dict[str, Any] = {}
         for info in self.table_columns:
             col, slot_idx = info.col, info.slot_idx
             if data_row.has_exc(slot_idx):

pixeltable/exprs/rowid_ref.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple
-from .sql_element_cache import SqlElementCache
+
+from typing import Any, Optional
 from uuid import UUID
 
 import sqlalchemy as sql
 
-from .expr import Expr
+import pixeltable.catalog as catalog
+import pixeltable.type_system as ts
+
 from .data_row import DataRow
+from .expr import Expr
 from .row_builder import RowBuilder
-import pixeltable.type_system as ts
-import pixeltable.catalog as catalog
+from .sql_element_cache import SqlElementCache
 
 
 class RowidRef(Expr):
@@ -49,14 +51,14 @@ class RowidRef(Expr):
         return self.normalized_base_id == other.normalized_base_id \
             and self.rowid_component_idx == other.rowid_component_idx
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() +\
             [('normalized_base_id', self.normalized_base_id), ('idx', self.rowid_component_idx)]
 
     def __str__(self) -> str:
         # check if this is the pos column of a component view
         tbl = self.tbl if self.tbl is not None else catalog.Catalog.get().tbl_versions[(self.tbl_id, None)]
-        if tbl.is_component_view() and self.rowid_component_idx == tbl.store_tbl.pos_col_idx:
+        if tbl.is_component_view() and self.rowid_component_idx == tbl.store_tbl.pos_col_idx:  # type: ignore[attr-defined]
             return catalog.globals._POS_COLUMN_NAME
         return ''
 
@@ -73,7 +75,7 @@ class RowidRef(Expr):
         self.tbl = tbl.tbl_version
         self.tbl_id = self.tbl.id
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         tbl = self.tbl if self.tbl is not None else catalog.Catalog.get().tbl_versions[(self.tbl_id, None)]
         rowid_cols = tbl.store_tbl.rowid_columns()
         return rowid_cols[self.rowid_component_idx]
@@ -81,7 +83,7 @@ class RowidRef(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         data_row[self.slot_idx] = data_row.pk[self.rowid_component_idx]
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {
             'tbl_id': str(self.tbl_id),
             'normalized_base_id': str(self.normalized_base_id),
@@ -89,7 +91,6 @@ class RowidRef(Expr):
         }
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> RowidRef:
         tbl_id, normalized_base_id, idx = UUID(d['tbl_id']), UUID(d['normalized_base_id']), d['idx']
         return cls(tbl=None, idx=idx, tbl_id=tbl_id, normalized_base_id=normalized_base_id)
-

pixeltable/exprs/similarity_expr.py

@@ -1,16 +1,16 @@
-from typing import Optional, List, Any
-from .sql_element_cache import SqlElementCache
+from typing import Any, Optional
 
 import sqlalchemy as sql
-import PIL.Image
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+
 from .column_ref import ColumnRef
 from .data_row import DataRow
 from .expr import Expr
 from .literal import Literal
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 
 class SimilarityExpr(Expr):
@@ -27,7 +27,7 @@ class SimilarityExpr(Expr):
 
         # determine index to use
         idx_info = col_ref.col.get_idx_info()
-        import pixeltable.index as index
+        from pixeltable import index
         embedding_idx_info = {
             info.name: info for info in idx_info.values() if isinstance(info.idx, index.EmbeddingIndex)
         }
@@ -44,6 +44,7 @@ class SimilarityExpr(Expr):
         else:
             self.idx_info = next(iter(embedding_idx_info.values()))
         idx = self.idx_info.idx
+        assert isinstance(idx, index.EmbeddingIndex)
 
         if item_expr.col_type.is_string_type() and idx.string_embed is None:
             raise excs.Error(
@@ -57,16 +58,20 @@ class SimilarityExpr(Expr):
     def __str__(self) -> str:
         return f'{self.components[0]}.similarity({self.components[1]})'
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not isinstance(self.components[1], Literal):
              raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
+        from pixeltable import index
+        assert isinstance(self.idx_info.idx, index.EmbeddingIndex)
         return self.idx_info.idx.similarity_clause(self.idx_info.val_col, item)
 
-    def as_order_by_clause(self, is_asc: bool) -> Optional[sql.ClauseElement]:
+    def as_order_by_clause(self, is_asc: bool) -> Optional[sql.ColumnElement]:
         if not isinstance(self.components[1], Literal):
             raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
+        from pixeltable import index
+        assert isinstance(self.idx_info.idx, index.EmbeddingIndex)
         return self.idx_info.idx.order_by_clause(self.idx_info.val_col, item, is_asc)
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
@@ -74,7 +79,7 @@ class SimilarityExpr(Expr):
         assert False
 
     @classmethod
-    def _from_dict(cls, d: dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> 'SimilarityExpr':
         assert len(components) == 2
         assert isinstance(components[0], ColumnRef)
         return cls(components[0], components[1])

pixeltable/exprs/sql_element_cache.py

@@ -1,4 +1,4 @@
-from typing import Iterable, Union, Optional
+from typing import Iterable, Union, Optional, cast
 
 import sqlalchemy as sql
 
@@ -27,8 +27,10 @@ class SqlElementCache:
         self.cache[e.id] = el
         return el
 
-    def contains(self, items: Union[Expr, Iterable[Expr]]) -> bool:
-        """Returns True if every item has a (non-None) sql.ColumnElement."""
-        if isinstance(items, Expr):
-            return self.get(items) is not None
+    def contains(self, item: Expr) -> bool:
+        """Returns True if the cache contains a (non-None) value for the given Expr."""
+        return self.get(item) is not None
+
+    def contains_all(self, items: Iterable[Expr]) -> bool:
+        """Returns True if the cache contains a (non-None) value for every item in the collection of Exprs."""
         return all(self.get(e) is not None for e in items)

pixeltable/exprs/type_cast.py

@@ -1,8 +1,9 @@
-from typing import Optional, Dict, List, Tuple, Any
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
 import pixeltable.type_system as ts
+
 from .expr import DataRow, Expr
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
@@ -15,7 +16,7 @@ class TypeCast(Expr):
     """
     def __init__(self, underlying: Expr, new_type: ts.ColumnType):
         super().__init__(new_type)
-        self.components: List[Expr] = [underlying]
+        self.components: list[Expr] = [underlying]
         self.id: Optional[int] = self._create_id()
 
     @property
@@ -26,10 +27,10 @@ class TypeCast(Expr):
         # `TypeCast` has no properties beyond those captured by `Expr`.
         return True
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('new_type', self.col_type)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         """
         sql_expr() is unimplemented for now, in order to sidestep potentially thorny
         questions about consistency of doing type conversions in both Python and Postgres.
@@ -40,11 +41,12 @@ class TypeCast(Expr):
         original_val = data_row[self._underlying.slot_idx]
         data_row[self.slot_idx] = self.col_type.create_literal(original_val)
 
-    def _as_dict(self) -> Dict:
+
+    def _as_dict(self) -> dict:
         return {'new_type': self.col_type.as_dict(), **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> 'TypeCast':
         assert 'new_type' in d
         assert len(components) == 1
         return cls(components[0], ts.ColumnType.from_dict(d['new_type']))

pixeltable/exprs/variable.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import List, Tuple, Any, Dict, NoReturn
+from typing import Any, NoReturn
 
 import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
@@ -20,7 +21,7 @@ class Variable(Expr):
         self.name = name
         self.id = self._create_id()
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('name', self.name)]
 
     def default_column_name(self) -> NoReturn:
@@ -38,9 +39,9 @@ class Variable(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> NoReturn:
         raise NotImplementedError()
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'name': self.name, 'type': self.col_type.as_dict(), **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, _: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, _: list[Expr]) -> Variable:
         return cls(d['name'], ts.ColumnType.from_dict(d['type']))