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

pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = '0.3.7'
-__version_tuple__ = (0, 3, 7)
+__version__ = '0.3.8'
+__version_tuple__ = (0, 3, 8)

pixeltable/catalog/column.py

@@ -132,6 +132,7 @@ class Column:
             from pixeltable import exprs
 
             self._value_expr = exprs.Expr.from_dict(self.value_expr_dict)
+            self._value_expr.bind_rel_paths()
             if not self._value_expr.is_valid:
                 message = (
                     dedent(

pixeltable/catalog/table_version.py

@@ -177,6 +177,10 @@ class TableVersion:
         # Init external stores (this needs to happen after the schema is created)
         self._init_external_stores(tbl_md)
 
+        # Force column metadata to load, in order to surface any invalid metadata now (as warnings)
+        for col in self.cols_by_id.values():
+            _ = col.value_expr
+
     def __hash__(self) -> int:
         return hash(self.id)
 

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

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:

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

@@ -129,7 +129,7 @@ class Expr(abc.ABC):
         """
         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
@@ -171,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:
         """
@@ -216,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:
@@ -253,10 +250,7 @@ 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."""
@@ -370,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]:
@@ -489,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:
@@ -520,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
@@ -792,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)

pixeltable/exprs/function_call.py

@@ -3,16 +3,12 @@ from __future__ import annotations
 import inspect
 import logging
 import sys
-import warnings
 from textwrap import dedent
 from typing import Any, Optional, Sequence, Union
 
 import sqlalchemy as sql
 
-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 .expr import Expr
@@ -156,22 +152,18 @@ class FunctionCall(Expr):
         return self.fn.name
 
     def _equals(self, other: FunctionCall) -> bool:
-        if self.fn != other.fn:
-            return False
-        if self.arg_idxs != other.arg_idxs:
-            return False
-        if self.kwarg_idxs != other.kwarg_idxs:
-            return False
-        if self.group_by_start_idx != other.group_by_start_idx:
-            return False
-        if self.group_by_stop_idx != other.group_by_stop_idx:
-            return False
-        if self.order_by_start_idx != other.order_by_start_idx:
-            return False
-        return True
+        return (
+            self.fn == other.fn
+            and self.arg_idxs == other.arg_idxs
+            and self.kwarg_idxs == other.kwarg_idxs
+            and self.group_by_start_idx == other.group_by_start_idx
+            and self.group_by_stop_idx == other.group_by_stop_idx
+            and self.order_by_start_idx == other.order_by_start_idx
+        )
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [
+        return [
+            *super()._id_attrs(),
             ('fn', id(self.fn)),  # use the function pointer, not the fqn, which isn't set for lambdas
             ('args', self.arg_idxs),
             ('kwargs', self.kwarg_idxs),
@@ -192,12 +184,12 @@ class FunctionCall(Expr):
         if self.is_method_call:
             return f'{self.components[0]}.{self.fn.name}({self._print_args(1, inline)})'
         else:
-            fn_name = self.fn.display_name if self.fn.display_name != '' else 'anonymous_fn'
+            fn_name = self.fn.display_name or 'anonymous_fn'
             return f'{fn_name}({self._print_args()})'
 
     def _print_args(self, start_idx: int = 0, inline: bool = True) -> str:
         arg_strs = [str(self.components[idx]) for idx in self.arg_idxs[start_idx:]]
-        arg_strs.extend([f'{param_name}={str(self.components[idx])}' for param_name, idx in self.kwarg_idxs.items()])
+        arg_strs.extend([f'{param_name}={self.components[idx]}' for param_name, idx in self.kwarg_idxs.items()])
         if len(self.order_by) > 0:
             assert isinstance(self.fn, func.AggregateFunction)
             if self.fn.requires_order_by:
@@ -297,7 +289,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters_by_pos[idx].kind
-                in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+                in {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
                 and not parameters_by_pos[idx].col_type.nullable
             ):
                 return None
@@ -310,7 +302,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters[param_name].kind
-                in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+                in {inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
                 and not parameters[param_name].col_type.nullable
             ):
                 return None
@@ -466,20 +458,18 @@ class FunctionCall(Expr):
                 # the call_return_type that we just inferred (which matches the deserialization behavior prior to
                 # version 25).
                 return_type = call_return_type
-            else:
-                # There is a return_type stored in metadata (schema version >= 25).
-                # Check that the stored return_type of the UDF call matches the column type of the FunctionCall, and
-                # fail-fast if it doesn't (otherwise we risk getting downstream database errors).
-                if not return_type.is_supertype_of(call_return_type, ignore_nullable=True):
-                    validation_error = dedent(
-                        f"""
-                        The return type stored in the database for a UDF call to {fn.self_path!r} no longer
-                        matches its return type as currently defined in the code. This probably means that the
-                        code for {fn.self_path!r} has changed in a backward-incompatible way.
-                        Return type of UDF call in the database: {return_type}
-                        Return type of UDF as currently defined in code: {call_return_type}
-                        """
-                    ).strip()
+            elif not return_type.is_supertype_of(call_return_type, ignore_nullable=True):
+                # There is a return_type stored in metadata (schema version >= 25),
+                # and the stored return_type of the UDF call doesn't match the column type of the FunctionCall.
+                validation_error = dedent(
+                    f"""
+                    The return type stored in the database for a UDF call to {fn.self_path!r} no longer
+                    matches its return type as currently defined in the code. This probably means that the
+                    code for {fn.self_path!r} has changed in a backward-incompatible way.
+                    Return type of UDF call in the database: {return_type}
+                    Return type of UDF as currently defined in code: {call_return_type}
+                    """
+                ).strip()
 
         fn_call = cls(
             resolved_fn,

pixeltable/exprs/globals.py

@@ -36,7 +36,7 @@ class ComparisonOperator(enum.Enum):
             return '>'
         if self == self.GE:
             return '>='
-        assert False
+        raise AssertionError()
 
     def reverse(self) -> ComparisonOperator:
         if self == self.LT:
@@ -62,7 +62,7 @@ class LogicalOperator(enum.Enum):
             return '|'
         if self == self.NOT:
             return '~'
-        assert False
+        raise AssertionError()
 
 
 class ArithmeticOperator(enum.Enum):
@@ -86,4 +86,4 @@ class ArithmeticOperator(enum.Enum):
             return '%'
         if self == self.FLOORDIV:
             return '//'
-        assert False
+        raise AssertionError()

pixeltable/exprs/in_predicate.py

@@ -71,7 +71,7 @@ class InPredicate(Expr):
         return self.value_list == other.value_list
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('value_list', self.value_list)]
+        return [*super()._id_attrs(), ('value_list', self.value_list)]
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         lhs_sql_exprs = sql_elements.get(self.components[0])

pixeltable/exprs/inline_expr.py

@@ -131,7 +131,7 @@ class InlineList(Expr):
     def as_literal(self) -> Optional[Literal]:
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
-        return Literal(list(c.as_literal().val for c in self.components), self.col_type)
+        return Literal([c.as_literal().val for c in self.components], self.col_type)
 
 
 class InlineDict(Expr):
@@ -166,7 +166,7 @@ class InlineDict(Expr):
         self.id = self._create_id()
 
     def __repr__(self) -> str:
-        item_strs = list(f"'{key}': {str(expr)}" for key, expr in zip(self.keys, self.components))
+        item_strs = [f"'{key}': {expr}" for key, expr in zip(self.keys, self.components)]
         return '{' + ', '.join(item_strs) + '}'
 
     def _equals(self, other: InlineDict) -> bool:
@@ -174,7 +174,7 @@ class InlineDict(Expr):
         return self.keys == other.keys
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('keys', self.keys)]
+        return [*super()._id_attrs(), ('keys', self.keys)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None

pixeltable/exprs/is_null.py

@@ -19,7 +19,7 @@ class IsNull(Expr):
         self.id = self._create_id()
 
     def __repr__(self) -> str:
-        return f'{str(self.components[0])} == None'
+        return f'{self.components[0]} == None'
 
     def _equals(self, other: IsNull) -> bool:
         return True

pixeltable/exprs/json_mapper.py

@@ -81,12 +81,12 @@ class JsonMapper(Expr):
         """
         We override equals() because we need to avoid comparing our scope anchor.
         """
-        if type(self) != type(other):
+        if type(self) is not type(other):
             return False
         return self._src_expr.equals(other._src_expr) and self._target_expr.equals(other._target_expr)
 
     def __repr__(self) -> str:
-        return f'{str(self._src_expr)} >> {str(self._target_expr)}'
+        return f'{self._src_expr} >> {self._target_expr}'
 
     @property
     def _src_expr(self) -> Expr:

pixeltable/exprs/json_path.py

@@ -6,14 +6,13 @@ import jmespath
 import sqlalchemy as sql
 
 import pixeltable as pxt
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
+from pixeltable import catalog, exceptions as excs, type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
 from .globals import print_slice
 from .json_mapper import JsonMapper
+from .object_ref import ObjectRef
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
@@ -50,8 +49,16 @@ class JsonPath(Expr):
         return f'{anchor_str}{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}'
 
     def _as_dict(self) -> dict:
+        assert len(self.components) <= 1
+        components_dict: dict[str, Any]
+        if len(self.components) == 0 or isinstance(self.components[0], ObjectRef):
+            # If the anchor is an ObjectRef, it means this JsonPath is a bound relative path. We store it as a relative
+            # path, *not* a bound path (which has no meaning in the dict).
+            components_dict = {}
+        else:
+            components_dict = super()._as_dict()
         path_elements = [[el.start, el.stop, el.step] if isinstance(el, slice) else el for el in self.path_elements]
-        return {'path_elements': path_elements, 'scope_idx': self.scope_idx, **super()._as_dict()}
+        return {'path_elements': path_elements, 'scope_idx': self.scope_idx, **components_dict}
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> JsonPath:
@@ -84,18 +91,18 @@ class JsonPath(Expr):
         Construct a relative path that references an ancestor of the immediately enclosing JsonMapper.
         """
         if not self.is_relative_path():
-            raise excs.Error(f'() for an absolute path is invalid')
+            raise excs.Error('() for an absolute path is invalid')
         if len(args) != 1 or not isinstance(args[0], int) or args[0] >= 0:
-            raise excs.Error(f'R() requires a negative index')
+            raise excs.Error('R() requires a negative index')
         return JsonPath(None, [], args[0])
 
     def __getattr__(self, name: str) -> 'JsonPath':
         assert isinstance(name, str)
-        return JsonPath(self._anchor, self.path_elements + [name])
+        return JsonPath(self._anchor, [*self.path_elements, name])
 
     def __getitem__(self, index: object) -> 'JsonPath':
         if isinstance(index, (int, slice, str)):
-            return JsonPath(self._anchor, self.path_elements + [index])
+            return JsonPath(self._anchor, [*self.path_elements, index])
         raise excs.Error(f'Invalid json list index: {index}')
 
     def __rshift__(self, other: object) -> 'JsonMapper':
@@ -120,7 +127,7 @@ class JsonPath(Expr):
 
         clean_name = ''.join(map(cleanup_char, ret_name))
         clean_name = clean_name.lstrip('_')  # remove leading underscore
-        if clean_name == '':
+        if not clean_name:  # Replace '' with None
             clean_name = None
 
         assert clean_name is None or catalog.is_valid_identifier(clean_name)
@@ -130,7 +137,7 @@ class JsonPath(Expr):
         return self.path_elements == other.path_elements
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('path_elements', self.path_elements)]
+        return [*super()._id_attrs(), ('path_elements', self.path_elements)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         """

pixeltable/exprs/literal.py

@@ -62,7 +62,7 @@ class Literal(Expr):
         return self.val == other.val
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('val', self.val)]
+        return [*super()._id_attrs(), ('val', self.val)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         # Return a sql object so that constants can participate in SQL expressions

pixeltable/exprs/method_ref.py

@@ -53,13 +53,13 @@ class MethodRef(Expr):
         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)]
+        return [*super()._id_attrs(), ('method_name', self.method_name)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
-        assert False, 'MethodRef cannot be evaluated directly'
+        raise AssertionError('MethodRef cannot be evaluated directly')
 
     def __repr__(self) -> str:
         return f'{self.base_expr}.{self.method_name}'