pixeltable 0.2.20__py3-none-any.whl → 0.2.22__py3-none-any.whl

pixeltable/exprs/in_predicate.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
-from typing import Optional, List, Any, Dict, Tuple, Iterable
+from typing import Any, Iterable, Optional
 
 import sqlalchemy as sql
 
 import pixeltable.exceptions as excs
-from .sql_element_cache import SqlElementCache
 import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 
 class InPredicate(Expr):
@@ -43,7 +44,7 @@ class InPredicate(Expr):
         assert len(self.components) == 2
         return self.components[1]
 
-    def _normalize_value_set(self, value_set: Any, filter_type_mismatches: bool = True) -> Iterable:
+    def _normalize_value_set(self, value_set: Iterable, filter_type_mismatches: bool = True) -> list:
         if not isinstance(value_set, Iterable):
             raise excs.Error(f'isin(): argument must be an Iterable (eg, list, dict, ...), not {value_set!r}')
         value_list = list(value_set)
@@ -68,10 +69,10 @@ class InPredicate(Expr):
     def _equals(self, other: InPredicate) -> bool:
         return self.value_list == other.value_list
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('value_list', self.value_list)]
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         lhs_sql_exprs = sql_elements.get(self.components[0])
         if lhs_sql_exprs is None or self.value_list is None:
             return None
@@ -86,11 +87,11 @@ class InPredicate(Expr):
             value_list = self._normalize_value_set(value_set, filter_type_mismatches=False)
             data_row[self.slot_idx] = lhs_val in value_list
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'value_list': self.value_list, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> InPredicate:
         assert 'value_list' in d
         assert len(components) <= 2
         return cls(components[0], d['value_list'], components[1] if len(components) == 2 else None)

pixeltable/exprs/inline_expr.py

@@ -73,7 +73,7 @@ class InlineArray(Expr):
         return super()._as_dict()
 
     @classmethod
-    def _from_dict(cls, _: dict, components: list[Expr]) -> Expr:
+    def _from_dict(cls, _: dict, components: list[Expr]) -> InlineArray:
         try:
             return cls(components)
         except excs.Error:
@@ -81,7 +81,7 @@ class InlineArray(Expr):
             # This is because in schema versions <= 19, `InlineArray` was serialized incorrectly, and
             # there is no way to determine the correct expression type until the subexpressions are
             # loaded and their types are known.
-            return InlineList(components)
+            return InlineList(components)  # type: ignore[return-value]
 
 
 class InlineList(Expr):
@@ -122,7 +122,7 @@ class InlineList(Expr):
         return super()._as_dict()
 
     @classmethod
-    def _from_dict(cls, _: dict, components: list[Expr]) -> Expr:
+    def _from_dict(cls, _: dict, components: list[Expr]) -> InlineList:
         return cls(components)
 
 
@@ -193,7 +193,7 @@ class InlineDict(Expr):
         return {'keys': self.keys, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: dict, components: list[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> InlineDict:
         assert 'keys' in d
         assert len(d['keys']) == len(components)
         arg = dict(zip(d['keys'], components))

pixeltable/exprs/is_null.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
-from typing import Optional, List, Dict
+from typing import Optional
 
 import sqlalchemy as sql
 
 import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
@@ -23,7 +24,7 @@ class IsNull(Expr):
     def _equals(self, other: IsNull) -> bool:
         return True
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         e = sql_elements.get(self.components[0])
         if e is None:
             return None
@@ -33,7 +34,6 @@ class IsNull(Expr):
         data_row[self.slot_idx] = data_row[self.components[0].slot_idx] is None
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> IsNull:
         assert len(components) == 1
         return cls(components[0])
-

pixeltable/exprs/json_mapper.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, List, Dict
+from typing import Optional
 
 import sqlalchemy as sql
 
@@ -18,7 +18,7 @@ class JsonMapper(Expr):
     is populated by JsonMapper.eval(). The JsonMapper effectively creates a new scope for its target expr.
     """
     def __init__(self, src_expr: Expr, target_expr: Expr):
-        # TODO: type spec should be List[target_expr.col_type]
+        # TODO: type spec should be list[target_expr.col_type]
         super().__init__(ts.JsonType())
 
         # we're creating a new scope, but we don't know yet whether this is nested within another JsonMapper;
@@ -32,7 +32,7 @@ class JsonMapper(Expr):
         self.target_expr_eval_ctx: Optional[RowBuilder.EvalCtx] = None
         self.id = self._create_id()
 
-    def bind_rel_paths(self, mapper: Optional[JsonMapper]) -> None:
+    def bind_rel_paths(self, mapper: Optional[JsonMapper] = None) -> None:
         self._src_expr.bind_rel_paths(mapper)
         self._target_expr.bind_rel_paths(self)
         self.parent_mapper = mapper
@@ -43,12 +43,12 @@ class JsonMapper(Expr):
         # need to ignore target_expr
         return self._src_expr.scope()
 
-    def dependencies(self) -> List[Expr]:
+    def dependencies(self) -> list[Expr]:
         result = [self._src_expr]
         result.extend(self._target_dependencies(self._target_expr))
         return result
 
-    def _target_dependencies(self, e: Expr) -> List[Expr]:
+    def _target_dependencies(self, e: Expr) -> list[Expr]:
         """
         Return all subexprs of e of which the scope isn't contained in target_expr_scope.
         Those need to be evaluated before us.
@@ -56,7 +56,7 @@ class JsonMapper(Expr):
         expr_scope = e.scope()
         if not expr_scope.is_contained_in(self.target_expr_scope):
             return [e]
-        result: List[Expr] = []
+        result: list[Expr] = []
         for c in e.components:
             result.extend(self._target_dependencies(c))
         return result
@@ -84,10 +84,10 @@ class JsonMapper(Expr):
     def scope_anchor(self) -> Expr:
         return self.components[2]
 
-    def _equals(self, other: JsonMapper) -> bool:
+    def _equals(self, _: JsonMapper) -> bool:
         return True
 
-    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:
@@ -104,19 +104,18 @@ class JsonMapper(Expr):
         for i, val in enumerate(src):
             data_row[self.scope_anchor.slot_idx] = val
             # stored target_expr
-            exc_tb = row_builder.eval(data_row, self.target_expr_eval_ctx)
-            assert exc_tb is None
+            row_builder.eval(data_row, self.target_expr_eval_ctx)
             result[i] = data_row[self._target_expr.slot_idx]
         data_row[self.slot_idx] = result
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         """
         We need to avoid serializing component[2], which is an ObjectRef.
         """
         return {'components': [c.as_dict() for c in self.components[0:2]]}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> JsonMapper:
         assert len(components) == 2
         return cls(components[0], components[1])
 

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:
@@ -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):