pixeltable 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

pixeltable/exec/in_memory_data_node.py

@@ -20,7 +20,8 @@ class InMemoryDataNode(ExecNode):
     - if an input row doesn't provide a value, sets the slot to the column default
     """
 
-    tbl: catalog.TableVersion
+    tbl: catalog.TableVersionHandle
+
     input_rows: list[dict[str, Any]]
     start_row_id: int
     output_rows: Optional[DataRowBatch]
@@ -29,12 +30,16 @@ class InMemoryDataNode(ExecNode):
     output_exprs: list[exprs.ColumnRef]
 
     def __init__(
-        self, tbl: catalog.TableVersion, rows: list[dict[str, Any]], row_builder: exprs.RowBuilder, start_row_id: int
+        self,
+        tbl: catalog.TableVersionHandle,
+        rows: list[dict[str, Any]],
+        row_builder: exprs.RowBuilder,
+        start_row_id: int,
     ):
         # we materialize the input slots
         output_exprs = list(row_builder.input_exprs)
         super().__init__(row_builder, output_exprs, [], None)
-        assert tbl.is_insertable()
+        assert tbl.get().is_insertable()
         self.tbl = tbl
         self.input_rows = rows
         self.start_row_id = start_row_id
@@ -62,7 +67,7 @@ class InMemoryDataNode(ExecNode):
 
                 if col_info.col.col_type.is_image_type() and isinstance(val, bytes):
                     # this is a literal image, ie, a sequence of bytes; we save this as a media file and store the path
-                    path = str(MediaStore.prepare_media_path(self.tbl.id, col_info.col.id, self.tbl.version))
+                    path = str(MediaStore.prepare_media_path(self.tbl.id, col_info.col.id, self.tbl.get().version))
                     open(path, 'wb').write(val)
                     val = path
                 self.output_rows[row_idx][col_info.slot_idx] = val

pixeltable/exec/row_update_node.py

@@ -3,7 +3,6 @@ from typing import Any, AsyncIterator
 
 import pixeltable.catalog as catalog
 import pixeltable.exprs as exprs
-from pixeltable.utils.media_store import MediaStore
 
 from .data_row_batch import DataRowBatch
 from .exec_node import ExecNode
@@ -40,7 +39,7 @@ class RowUpdateNode(ExecNode):
             if isinstance(col_ref, exprs.ColumnRef)
         }
         self.col_slot_idxs = {col: all_col_slot_idxs[col] for col in col_vals_batch[0].keys()}
-        self.key_slot_idxs = {col: all_col_slot_idxs[col] for col in tbl.tbl_version.primary_key_columns()}
+        self.key_slot_idxs = {col: all_col_slot_idxs[col] for col in tbl.tbl_version.get().primary_key_columns()}
         self.matched_key_vals: set[tuple] = set()
 
     async def __aiter__(self) -> AsyncIterator[DataRowBatch]:

pixeltable/exec/sql_node.py

@@ -1,13 +1,14 @@
 import logging
 import warnings
 from decimal import Decimal
-from typing import TYPE_CHECKING, AsyncIterator, Iterable, Iterator, NamedTuple, Optional, Sequence
+from typing import TYPE_CHECKING, AsyncIterator, Iterable, NamedTuple, Optional, Sequence
 from uuid import UUID
 
 import sqlalchemy as sql
 
 import pixeltable.catalog as catalog
 import pixeltable.exprs as exprs
+from pixeltable.env import Env
 
 from .data_row_batch import DataRowBatch
 from .exec_node import ExecNode
@@ -122,7 +123,7 @@ class SqlNode(ExecNode):
         if set_pk:
             # we also need to retrieve the pk columns
             assert tbl is not None
-            self.num_pk_cols = len(tbl.tbl_version.store_tbl.pk_columns())
+            self.num_pk_cols = len(tbl.tbl_version.get().store_tbl.pk_columns())
 
         # additional state
         self.result_cursor = None
@@ -142,7 +143,7 @@ class SqlNode(ExecNode):
         sql_select_list = [self.sql_elements.get(e) for e in self.select_list]
         if self.set_pk:
             assert self.tbl is not None
-            sql_select_list += self.tbl.tbl_version.store_tbl.pk_columns()
+            sql_select_list += self.tbl.tbl_version.get().store_tbl.pk_columns()
         stmt = sql.select(*sql_select_list)
 
         where_clause_element = (
@@ -215,29 +216,31 @@ class SqlNode(ExecNode):
             exact_version_only = set()
         candidates = tbl.get_tbl_versions()
         assert len(candidates) > 0
-        joined_tbls: list[catalog.TableVersion] = [candidates[0]]
+        joined_tbls: list[catalog.TableVersionHandle] = [candidates[0]]
         for tbl in candidates[1:]:
             if tbl.id in refd_tbl_ids:
                 joined_tbls.append(tbl)
 
         first = True
-        prev_tbl: catalog.TableVersion
+        prev_tbl: catalog.TableVersionHandle
         for tbl in joined_tbls[::-1]:
             if first:
-                stmt = stmt.select_from(tbl.store_tbl.sa_tbl)
+                stmt = stmt.select_from(tbl.get().store_tbl.sa_tbl)
                 first = False
             else:
                 # join tbl to prev_tbl on prev_tbl's rowid cols
-                prev_tbl_rowid_cols = prev_tbl.store_tbl.rowid_columns()
-                tbl_rowid_cols = tbl.store_tbl.rowid_columns()
+                prev_tbl_rowid_cols = prev_tbl.get().store_tbl.rowid_columns()
+                tbl_rowid_cols = tbl.get().store_tbl.rowid_columns()
                 rowid_clauses = [
                     c1 == c2 for c1, c2 in zip(prev_tbl_rowid_cols, tbl_rowid_cols[: len(prev_tbl_rowid_cols)])
                 ]
-                stmt = stmt.join(tbl.store_tbl.sa_tbl, sql.and_(*rowid_clauses))
+                stmt = stmt.join(tbl.get().store_tbl.sa_tbl, sql.and_(*rowid_clauses))
             if tbl.id in exact_version_only:
-                stmt = stmt.where(tbl.store_tbl.v_min_col == tbl.version)
+                stmt = stmt.where(tbl.get().store_tbl.v_min_col == tbl.get().version)
             else:
-                stmt = stmt.where(tbl.store_tbl.v_min_col <= tbl.version).where(tbl.store_tbl.v_max_col > tbl.version)
+                stmt = stmt.where(tbl.get().store_tbl.v_min_col <= tbl.get().version).where(
+                    tbl.get().store_tbl.v_max_col > tbl.get().version
+                )
             prev_tbl = tbl
         return stmt
 
@@ -264,10 +267,11 @@ class SqlNode(ExecNode):
         self.limit = limit
 
     def _log_explain(self, stmt: sql.Select) -> None:
+        conn = Env.get().conn
         try:
             # don't set dialect=Env.get().engine.dialect: x % y turns into x %% y, which results in a syntax error
             stmt_str = str(stmt.compile(compile_kwargs={'literal_binds': True}))
-            explain_result = self.ctx.conn.execute(sql.text(f'EXPLAIN {stmt_str}'))
+            explain_result = conn.execute(sql.text(f'EXPLAIN {stmt_str}'))
             explain_str = '\n'.join([str(row) for row in explain_result])
             _logger.debug(f'SqlScanNode explain:\n{explain_str}')
         except Exception as e:
@@ -275,7 +279,6 @@ class SqlNode(ExecNode):
 
     async def __aiter__(self) -> AsyncIterator[DataRowBatch]:
         # run the query; do this here rather than in _open(), exceptions are only expected during iteration
-        assert self.ctx.conn is not None
         with warnings.catch_warnings(record=True) as w:
             stmt = self._create_stmt()
             try:
@@ -286,7 +289,8 @@ class SqlNode(ExecNode):
                 pass
             self._log_explain(stmt)
 
-            result_cursor = self.ctx.conn.execute(stmt)
+            conn = Env.get().conn
+            result_cursor = conn.execute(stmt)
             for warning in w:
                 pass
 
@@ -351,7 +355,7 @@ class SqlScanNode(SqlNode):
     Supports filtering and ordering.
     """
 
-    exact_version_only: list[catalog.TableVersion]
+    exact_version_only: list[catalog.TableVersionHandle]
 
     def __init__(
         self,
@@ -359,7 +363,7 @@ class SqlScanNode(SqlNode):
         row_builder: exprs.RowBuilder,
         select_list: Iterable[exprs.Expr],
         set_pk: bool = False,
-        exact_version_only: Optional[list[catalog.TableVersion]] = None,
+        exact_version_only: Optional[list[catalog.TableVersionHandle]] = None,
     ):
         """
         Args:

pixeltable/exprs/__init__.py

@@ -1,3 +1,5 @@
+# ruff: noqa: F401
+
 from .arithmetic_expr import ArithmeticExpr
 from .array_slice import ArraySlice
 from .column_property_ref import ColumnPropertyRef

pixeltable/exprs/arithmetic_expr.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 
-from typing import Any, Optional, Union
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
-import pixeltable.exceptions as excs
-import pixeltable.exprs as exprs
-import pixeltable.type_system as ts
+from pixeltable import exceptions as excs, type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
@@ -50,13 +48,13 @@ class ArithmeticExpr(Expr):
         # add parentheses around operands that are ArithmeticExprs to express precedence
         op1_str = f'({self._op1})' if isinstance(self._op1, ArithmeticExpr) else str(self._op1)
         op2_str = f'({self._op2})' if isinstance(self._op2, ArithmeticExpr) else str(self._op2)
-        return f'{op1_str} {str(self.operator)} {op2_str}'
+        return f'{op1_str} {self.operator} {op2_str}'
 
     def _equals(self, other: ArithmeticExpr) -> bool:
         return self.operator == other.operator
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('operator', self.operator.value)]
+        return [*super()._id_attrs(), ('operator', self.operator.value)]
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         assert self.col_type.is_int_type() or self.col_type.is_float_type() or self.col_type.is_json_type()
@@ -95,7 +93,7 @@ class ArithmeticExpr(Expr):
                 return sql.sql.expression.cast(sql.func.floor(left / nullif), self.col_type.to_sa_type())
             if self.col_type.is_float_type():
                 return sql.sql.expression.cast(sql.func.floor(left / nullif), self.col_type.to_sa_type())
-        assert False
+        raise AssertionError()
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         op1_val = data_row[self._op1.slot_idx]
@@ -113,9 +111,7 @@ class ArithmeticExpr(Expr):
 
         data_row[self.slot_idx] = self.eval_nullable(op1_val, op2_val)
 
-    def eval_nullable(
-        self, op1_val: Union[int, float, None], op2_val: Union[int, float, None]
-    ) -> Union[int, float, None]:
+    def eval_nullable(self, op1_val: Optional[float], op2_val: Optional[float]) -> Optional[float]:
         """
         Return the result of evaluating the expression on two nullable int/float operands,
         None is interpreted as SQL NULL
@@ -124,7 +120,7 @@ class ArithmeticExpr(Expr):
             return None
         return self.eval_non_null(op1_val, op2_val)
 
-    def eval_non_null(self, op1_val: Union[int, float], op2_val: Union[int, float]) -> Union[int, float]:
+    def eval_non_null(self, op1_val: float, op2_val: float) -> float:
         """
         Return the result of evaluating the expression on two int/float operands
         """

pixeltable/exprs/array_slice.py

@@ -41,7 +41,7 @@ class ArraySlice(Expr):
         return self.index == other.index
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('index', self.index)]
+        return [*super()._id_attrs(), ('index', self.index)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None

pixeltable/exprs/column_property_ref.py

@@ -40,7 +40,7 @@ class ColumnPropertyRef(Expr):
         return self.prop == other.prop
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('prop', self.prop.value)]
+        return [*super()._id_attrs(), ('prop', self.prop.value)]
 
     @property
     def _col_ref(self) -> ColumnRef:
@@ -52,7 +52,7 @@ class ColumnPropertyRef(Expr):
         return f'{self._col_ref}.{self.prop.name.lower()}'
 
     def is_error_prop(self) -> bool:
-        return self.prop == self.Property.ERRORTYPE or self.prop == self.Property.ERRORMSG
+        return self.prop in {self.Property.ERRORTYPE, self.Property.ERRORMSG}
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not self._col_ref.col.is_stored:
@@ -95,7 +95,7 @@ class ColumnPropertyRef(Expr):
             else:
                 data_row[self.slot_idx] = str(exc)
         else:
-            assert False
+            raise AssertionError()
 
     def _as_dict(self) -> dict:
         return {'prop': self.prop.value, **super()._as_dict()}

pixeltable/exprs/column_ref.py

@@ -6,9 +6,7 @@ from uuid import UUID
 import sqlalchemy as sql
 
 import pixeltable as pxt
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.iterators as iters
+from pixeltable import catalog, exceptions as excs, iterators as iters
 
 from ..utils.description_helper import DescriptionHelper
 from .data_row import DataRow
@@ -52,15 +50,15 @@ class ColumnRef(Expr):
         assert col.tbl is not None
         self.col = col
         self.is_unstored_iter_col = (
-            col.tbl.is_component_view() and col.tbl.is_iterator_column(col) and not col.is_stored
+            col.tbl.get().is_component_view and col.tbl.get().is_iterator_column(col) and not col.is_stored
         )
         self.iter_arg_ctx = None
         # number of rowid columns in the base table
-        self.base_rowid_len = col.tbl.base.num_rowid_columns() if self.is_unstored_iter_col else 0
+        self.base_rowid_len = col.tbl.get().base.get().num_rowid_columns() if self.is_unstored_iter_col else 0
         self.base_rowid = [None] * self.base_rowid_len
         self.iterator = None
         # index of the position column in the view's primary key; don't try to reference tbl.store_tbl here
-        self.pos_idx = col.tbl.num_rowid_columns() - 1 if self.is_unstored_iter_col else None
+        self.pos_idx = col.tbl.get().num_rowid_columns() - 1 if self.is_unstored_iter_col else None
 
         self.perform_validation = False
         if col.col_type.is_media_type():
@@ -84,7 +82,8 @@ class ColumnRef(Expr):
         assert len(self.iter_arg_ctx.target_slot_idxs) == 1  # a single inline dict
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [
+        return [
+            *super()._id_attrs(),
             ('tbl_id', self.col.tbl.id),
             ('col_id', self.col.id),
             ('perform_validation', self.perform_validation),
@@ -138,7 +137,7 @@ class ColumnRef(Expr):
         return self.col == other.col and self.perform_validation == other.perform_validation
 
     def _df(self) -> 'pxt.dataframe.DataFrame':
-        tbl = catalog.Catalog.get().tbls[self.col.tbl.id]
+        tbl = catalog.Catalog.get().get_tbl(self.col.tbl.id)
         return tbl.select(self)
 
     def show(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
@@ -166,9 +165,9 @@ class ColumnRef(Expr):
         return self._descriptors().to_html()
 
     def _descriptors(self) -> DescriptionHelper:
-        tbl = catalog.Catalog.get().tbls[self.col.tbl.id]
+        tbl = catalog.Catalog.get().get_tbl(self.col.tbl.id)
         helper = DescriptionHelper()
-        helper.append(f'Column\n{self.col.name!r}\n(of table {tbl._path!r})')
+        helper.append(f'Column\n{self.col.name!r}\n(of table {tbl._path()!r})')
         helper.append(tbl._col_descriptor([self.col.name]))
         idxs = tbl._index_descriptor([self.col.name])
         if len(idxs) > 0:
@@ -217,7 +216,7 @@ class ColumnRef(Expr):
         if self.base_rowid != data_row.pk[: self.base_rowid_len]:
             row_builder.eval(data_row, self.iter_arg_ctx)
             iterator_args = data_row[self.iter_arg_ctx.target_slot_idxs[0]]
-            self.iterator = self.col.tbl.iterator_cls(**iterator_args)
+            self.iterator = self.col.tbl.get().iterator_cls(**iterator_args)
             self.base_rowid = data_row.pk[: self.base_rowid_len]
         self.iterator.set_pos(data_row.pk[self.pos_idx])
         res = next(self.iterator)
@@ -225,7 +224,7 @@ class ColumnRef(Expr):
 
     def _as_dict(self) -> dict:
         tbl = self.col.tbl
-        version = tbl.version if tbl.is_snapshot else None
+        version = tbl.get().version if tbl.get().is_snapshot else None
         # we omit self.components, even if this is a validating ColumnRef, because init() will recreate the
         # non-validating component ColumnRef
         return {
@@ -238,7 +237,7 @@ class ColumnRef(Expr):
     @classmethod
     def get_column(cls, d: dict) -> catalog.Column:
         tbl_id, version, col_id = UUID(d['tbl_id']), d['tbl_version'], d['col_id']
-        tbl_version = catalog.Catalog.get().tbl_versions[(tbl_id, version)]
+        tbl_version = catalog.Catalog.get().get_tbl_version(tbl_id, version)
         # don't use tbl_version.cols_by_id here, this might be a snapshot reference to a column that was then dropped
         col = next(col for col in tbl_version.cols if col.id == col_id)
         return col

pixeltable/exprs/comparison.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
@@ -15,9 +15,6 @@ from .literal import Literal
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
-if TYPE_CHECKING:
-    from pixeltable import index
-
 
 class Comparison(Expr):
     is_search_arg_comparison: bool
@@ -62,7 +59,7 @@ class Comparison(Expr):
         return self.operator == other.operator
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('operator', self.operator.value)]
+        return [*super()._id_attrs(), ('operator', self.operator.value)]
 
     @property
     def _op1(self) -> Expr:
@@ -84,7 +81,7 @@ class Comparison(Expr):
         if self.is_search_arg_comparison:
             # reference the index value column if there is an index and this is not a snapshot
             # (indices don't apply to snapshots)
-            tbl = self._op1.col.tbl
+            tbl = self._op1.col.tbl.get()
             idx_info = [
                 info for info in self._op1.col.get_idx_info().values() if isinstance(info.idx, index.BtreeIndex)
             ]

pixeltable/exprs/compound_predicate.py

@@ -5,7 +5,7 @@ from typing import Any, Callable, Optional
 
 import sqlalchemy as sql
 
-import pixeltable.type_system as ts
+from pixeltable import type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
@@ -58,10 +58,10 @@ class CompoundPredicate(Expr):
         return self.operator == other.operator
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('operator', self.operator.value)]
+        return [*super()._id_attrs(), ('operator', self.operator.value)]
 
     def split_conjuncts(self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
-        if self.operator == LogicalOperator.OR or self.operator == LogicalOperator.NOT:
+        if self.operator in {LogicalOperator.OR, LogicalOperator.NOT}:
             return super().split_conjuncts(condition)
         matches = [op for op in self.components if condition(op)]
         non_matches = [op for op in self.components if not condition(op)]
@@ -83,7 +83,7 @@ class CompoundPredicate(Expr):
         if self.operator == LogicalOperator.NOT:
             data_row[self.slot_idx] = not data_row[self.components[0].slot_idx]
         else:
-            val = True if self.operator == LogicalOperator.AND else False
+            val = self.operator == LogicalOperator.AND
             op_function = operator.and_ if self.operator == LogicalOperator.AND else operator.or_
             for op in self.components:
                 val = op_function(val, data_row[op.slot_idx])

pixeltable/exprs/expr.py

@@ -14,10 +14,7 @@ import numpy as np
 import sqlalchemy as sql
 from typing_extensions import Self, _AnnotatedAlias
 
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.func as func
-import pixeltable.type_system as ts
+from pixeltable import catalog, exceptions as excs, func, type_system as ts
 
 from .data_row import DataRow
 from .globals import ArithmeticOperator, ComparisonOperator, LiteralPythonTypes, LogicalOperator
@@ -110,11 +107,29 @@ class Expr(abc.ABC):
         """
         return None
 
+    @property
+    def validation_error(self) -> Optional[str]:
+        """
+        Subclasses can override this to indicate that validation has failed after a catalog load.
+
+        If an Expr (or any of its transitive components) is invalid, then it cannot be evaluated, but its metadata
+        will still be preserved in the catalog (so that the user can take appropriate corrective action).
+        """
+        for c in self.components:
+            error = c.validation_error
+            if error is not None:
+                return error
+        return None
+
+    @property
+    def is_valid(self) -> bool:
+        return self.validation_error is None
+
     def equals(self, other: Expr) -> bool:
         """
         Subclass-specific comparison. Implemented as a function because __eq__() is needed to construct Comparisons.
         """
-        if type(self) != type(other):
+        if type(self) is not type(other):
             return False
         if len(self.components) != len(other.components):
             return False
@@ -156,10 +171,7 @@ class Expr(abc.ABC):
     def list_equals(cls, a: list[Expr], b: list[Expr]) -> bool:
         if len(a) != len(b):
             return False
-        for i in range(len(a)):
-            if not a[i].equals(b[i]):
-                return False
-        return True
+        return all(a[i].equals(b[i]) for i in range(len(a)))
 
     def copy(self) -> Expr:
         """
@@ -201,9 +213,9 @@ class Expr(abc.ABC):
                 return new.copy()
         for i in range(len(self.components)):
             self.components[i] = self.components[i].substitute(spec)
-        self = self.maybe_literal()
-        self.id = self._create_id()
-        return self
+        result = self.maybe_literal()
+        result.id = result._create_id()
+        return result
 
     @classmethod
     def list_substitute(cls, expr_list: list[Expr], spec: dict[Expr, Expr]) -> None:
@@ -238,14 +250,11 @@ class Expr(abc.ABC):
         from .column_ref import ColumnRef
 
         col_refs = self.subexprs(ColumnRef)
-        for col_ref in col_refs:
-            if not any(tbl.has_column(col_ref.col) for tbl in tbls):
-                return False
-        return True
+        return all(any(tbl.has_column(col_ref.col) for tbl in tbls) for col_ref in col_refs)
 
     def retarget(self, tbl: catalog.TableVersionPath) -> Self:
         """Retarget ColumnRefs in this expr to the specific TableVersions in tbl."""
-        tbl_versions = {tbl_version.id: tbl_version for tbl_version in tbl.get_tbl_versions()}
+        tbl_versions = {tbl_version.id: tbl_version.get() for tbl_version in tbl.get_tbl_versions()}
         return self._retarget(tbl_versions)
 
     def _retarget(self, tbl_versions: dict[UUID, catalog.TableVersion]) -> Self:
@@ -355,7 +364,7 @@ class Expr(abc.ABC):
 
     @classmethod
     def all_tbl_ids(cls, exprs_: Iterable[Expr]) -> set[UUID]:
-        return set(tbl_id for e in exprs_ for tbl_id in e.tbl_ids())
+        return {tbl_id for e in exprs_ for tbl_id in e.tbl_ids()}
 
     @classmethod
     def get_refd_columns(cls, expr_dict: dict[str, Any]) -> list[catalog.Column]:
@@ -474,7 +483,7 @@ class Expr(abc.ABC):
         return {'_classname': self.__class__.__name__, **self._as_dict()}
 
     @classmethod
-    def as_dict_list(self, expr_list: list[Expr]) -> list[dict]:
+    def as_dict_list(cls, expr_list: list[Expr]) -> list[dict]:
         return [e.as_dict() for e in expr_list]
 
     def _as_dict(self) -> dict:
@@ -505,7 +514,7 @@ class Expr(abc.ABC):
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> Self:
-        assert False, 'not implemented'
+        raise AssertionError('not implemented')
 
     def isin(self, value_set: Any) -> 'exprs.InPredicate':
         from .in_predicate import InPredicate
@@ -777,13 +786,13 @@ class Expr(abc.ABC):
             first_param = next(params_iter) if len(params) >= 1 else None
             second_param = next(params_iter) if len(params) >= 2 else None
             # Check that fn has at least one positional parameter
-            if len(params) == 0 or first_param.kind in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.VAR_KEYWORD):
+            if len(params) == 0 or first_param.kind in {inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.VAR_KEYWORD}:
                 raise excs.Error(f'Function `{fn.__name__}` has no positional parameters.')
             # Check that fn has at most one required parameter, i.e., its second parameter
             # has no default and is not a varargs
             if (
                 len(params) >= 2
-                and second_param.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+                and second_param.kind not in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}
                 and second_param.default is inspect.Parameter.empty
             ):
                 raise excs.Error(f'Function `{fn.__name__}` has multiple required parameters.')

pixeltable/exprs/expr_dict.py

@@ -1,9 +1,9 @@
 from typing import Generic, Iterable, Iterator, Optional, TypeVar
 
-T = TypeVar('T')
-
 from .expr import Expr
 
+T = TypeVar('T')
+
 
 class ExprDict(Generic[T]):
     """
@@ -47,7 +47,7 @@ class ExprDict(Generic[T]):
         self._data.clear()
 
     def keys(self) -> Iterator[Expr]:
-        return self.__iter__()
+        return iter(self)
 
     def values(self) -> Iterator[T]:
         return (value for _, value in self._data.values())

pixeltable/exprs/expr_set.py

@@ -46,7 +46,7 @@ class ExprSet(Generic[T]):
 
     def __getitem__(self, index: object) -> Optional[T]:
         """Indexed lookup by slot_idx or Expr.id."""
-        assert isinstance(index, int) or isinstance(index, Expr)
+        assert isinstance(index, (int, Expr))
         if isinstance(index, int):
             # return expr with matching slot_idx
             return self.exprs_by_idx.get(index)