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

pixeltable/exprs/expr.py

@@ -13,7 +13,6 @@ from uuid import UUID
 import sqlalchemy as sql
 from typing_extensions import _AnnotatedAlias, Self
 
-import pixeltable
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.func as func
@@ -91,7 +90,7 @@ class Expr(abc.ABC):
                 result = c_scope
         return result
 
-    def bind_rel_paths(self, mapper: Optional['pixeltable.exprs.JsonMapper'] = None) -> None:
+    def bind_rel_paths(self, mapper: Optional['exprs.JsonMapper'] = None) -> None:
         """
         Binds relative JsonPaths to mapper.
         This needs to be done in a separate phase after __init__(), because RelativeJsonPath()(-1) cannot be resolved
@@ -121,7 +120,7 @@ class Expr(abc.ABC):
                 return False
         return self._equals(other)
 
-    def _equals(self, other: Expr) -> bool:
+    def _equals(self, other: Self) -> bool:
         # we already compared the type and components in equals(); subclasses that require additional comparisons
         # override this
         return True
@@ -232,12 +231,6 @@ class Expr(abc.ABC):
         return self._retarget(tbl_versions)
 
     def _retarget(self, tbl_versions: dict[UUID, catalog.TableVersion]) -> Self:
-        from .column_ref import ColumnRef
-        if isinstance(self, ColumnRef):
-            target = tbl_versions[self.col.tbl.id]
-            assert self.col.id in target.cols_by_id
-            col = target.cols_by_id[self.col.id]
-            return ColumnRef(col)
         for i in range (len(self.components)):
             self.components[i] = self.components[i]._retarget(tbl_versions)
         return self
@@ -289,22 +282,24 @@ class Expr(abc.ABC):
             for c in self.components:
                 yield from c.subexprs(expr_class=expr_class, filter=filter, traverse_matches=traverse_matches)
         if is_match:
-            yield self
+            yield self  # type: ignore[misc]
 
     @overload
+    @classmethod
     def list_subexprs(
-        expr_list: Iterable[Expr], *, filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
+        cls, expr_list: Iterable[Expr], *, filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
     ) -> Iterator[Expr]: ...
 
     @overload
+    @classmethod
     def list_subexprs(
-        expr_list: list[Expr], expr_class: type[T], filter: Optional[Callable[[Expr], bool]] = None,
+        cls, expr_list: Iterable[Expr], expr_class: type[T], filter: Optional[Callable[[Expr], bool]] = None,
         traverse_matches: bool = True
     ) -> Iterator[T]: ...
 
     @classmethod
     def list_subexprs(
-        cls, expr_list: list[Expr], expr_class: Optional[type[T]] = None,
+        cls, expr_list: Iterable[Expr], expr_class: Optional[type[T]] = None,
         filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
     ) -> Iterator[T]:
         """Produce subexprs for all exprs in list. Can contain duplicates."""
@@ -329,11 +324,8 @@ class Expr(abc.ABC):
         return {ref.col.tbl.id for ref in self.subexprs(ColumnRef)} | {ref.tbl.id for ref in self.subexprs(RowidRef)}
 
     @classmethod
-    def list_tbl_ids(cls, expr_list: list[Expr]) -> set[UUID]:
-        ids: set[UUID] = set()
-        for e in expr_list:
-            ids.update(e.tbl_ids())
-        return ids
+    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())
 
     @classmethod
     def get_refd_columns(cls, expr_dict: dict[str, Any]) -> list[catalog.Column]:
@@ -383,7 +375,7 @@ class Expr(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def eval(self, data_row: DataRow, row_builder: 'pixeltable.exprs.RowBuilder') -> None:
+    def eval(self, data_row: DataRow, row_builder: 'exprs.RowBuilder') -> None:
         """
         Compute the expr value for data_row and store the result in data_row[slot_idx].
         Not called if sql_expr() != None (exception: Literal).
@@ -449,18 +441,18 @@ class Expr(abc.ABC):
     def _from_dict(cls, d: dict, components: list[Expr]) -> Self:
         assert False, 'not implemented'
 
-    def isin(self, value_set: Any) -> 'pixeltable.exprs.InPredicate':
+    def isin(self, value_set: Any) -> 'exprs.InPredicate':
         from .in_predicate import InPredicate
         if isinstance(value_set, Expr):
             return InPredicate(self, value_set_expr=value_set)
         else:
             return InPredicate(self, value_set_literal=value_set)
 
-    def astype(self, new_type: Union[ts.ColumnType, type, _AnnotatedAlias]) -> 'pixeltable.exprs.TypeCast':
+    def astype(self, new_type: Union[ts.ColumnType, type, _AnnotatedAlias]) -> 'exprs.TypeCast':
         from pixeltable.exprs import TypeCast
         return TypeCast(self, ts.ColumnType.normalize_type(new_type))
 
-    def apply(self, fn: Callable, *, col_type: Union[ts.ColumnType, type, _AnnotatedAlias, None] = None) -> 'pixeltable.exprs.FunctionCall':
+    def apply(self, fn: Callable, *, col_type: Union[ts.ColumnType, type, _AnnotatedAlias, None] = None) -> 'exprs.FunctionCall':
         if col_type is not None:
             col_type = ts.ColumnType.normalize_type(col_type)
         function = self._make_applicator_function(fn, col_type)
@@ -475,23 +467,32 @@ class Expr(abc.ABC):
         ]
         return attrs
 
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        raise NotImplementedError(f'Expression of type `{type(self)}` is not callable')
+
     def __getitem__(self, index: object) -> Expr:
         if self.col_type.is_json_type():
             from .json_path import JsonPath
-            return JsonPath(self).__getitem__(index)
+            return JsonPath(self)[index]
         if self.col_type.is_array_type():
             from .array_slice import ArraySlice
+            if not isinstance(index, tuple):
+                index = (index,)
+            if any(not isinstance(i, (int, slice)) for i in index):
+                raise AttributeError(f'Invalid array indices: {index}')
             return ArraySlice(self, index)
         raise AttributeError(f'Type {self.col_type} is not subscriptable')
 
-    def __getattr__(self, name: str) -> Union['pixeltable.exprs.MethodRef', 'pixeltable.exprs.FunctionCall', 'pixeltable.exprs.JsonPath']:
+    def __getattr__(self, name: str) -> 'exprs.Expr':
         """
         ex.: <img col>.rotate(60)
         """
+        from .json_path import JsonPath
+        from .method_ref import MethodRef
         if self.col_type.is_json_type():
-            return pixeltable.exprs.JsonPath(self).__getattr__(name)
+            return JsonPath(self).__getattr__(name)
         else:
-            method_ref = pixeltable.exprs.MethodRef(self, name)
+            method_ref = MethodRef(self, name)
             if method_ref.fn.is_property:
                 # Marked as a property, so autoinvoke the method to obtain a `FunctionCall`
                 assert method_ref.fn.arity == 1
@@ -504,32 +505,32 @@ class Expr(abc.ABC):
         raise TypeError(
             'Pixeltable expressions cannot be used in conjunction with Python boolean operators (and/or/not)')
 
-    def __lt__(self, other: object) -> 'pixeltable.exprs.Comparison':
+    def __lt__(self, other: object) -> 'exprs.Comparison':
         return self._make_comparison(ComparisonOperator.LT, other)
 
-    def __le__(self, other: object) -> 'pixeltable.exprs.Comparison':
+    def __le__(self, other: object) -> 'exprs.Comparison':
         return self._make_comparison(ComparisonOperator.LE, other)
 
-    def __eq__(self, other: object) -> 'pixeltable.exprs.Comparison':
+    def __eq__(self, other: object) -> 'exprs.Expr':  # type: ignore[override]
         if other is None:
             from .is_null import IsNull
             return IsNull(self)
         return self._make_comparison(ComparisonOperator.EQ, other)
 
-    def __ne__(self, other: object) -> 'pixeltable.exprs.Comparison':
+    def __ne__(self, other: object) -> 'exprs.Expr':  # type: ignore[override]
         if other is None:
             from .compound_predicate import CompoundPredicate
             from .is_null import IsNull
             return CompoundPredicate(LogicalOperator.NOT, [IsNull(self)])
         return self._make_comparison(ComparisonOperator.NE, other)
 
-    def __gt__(self, other: object) -> 'pixeltable.exprs.Comparison':
+    def __gt__(self, other: object) -> 'exprs.Comparison':
         return self._make_comparison(ComparisonOperator.GT, other)
 
-    def __ge__(self, other: object) -> 'pixeltable.exprs.Comparison':
+    def __ge__(self, other: object) -> 'exprs.Comparison':
         return self._make_comparison(ComparisonOperator.GE, other)
 
-    def _make_comparison(self, op: ComparisonOperator, other: object) -> 'pixeltable.exprs.Comparison':
+    def _make_comparison(self, op: ComparisonOperator, other: object) -> 'exprs.Comparison':
         """
         other: Union[Expr, LiteralPythonTypes]
         """
@@ -539,49 +540,49 @@ class Expr(abc.ABC):
         if isinstance(other, Expr):
             return Comparison(op, self, other)
         if isinstance(other, typing.get_args(LiteralPythonTypes)):
-            return Comparison(op, self, Literal(other))  # type: ignore[arg-type]
+            return Comparison(op, self, Literal(other))
         raise TypeError(f'Other must be Expr or literal: {type(other)}')
 
-    def __neg__(self) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __neg__(self) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.MUL, -1)
 
-    def __add__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __add__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.ADD, other)
 
-    def __sub__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __sub__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.SUB, other)
 
-    def __mul__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __mul__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.MUL, other)
 
-    def __truediv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __truediv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.DIV, other)
 
-    def __mod__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __mod__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.MOD, other)
 
-    def __floordiv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __floordiv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
 
-    def __radd__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __radd__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.ADD, other)
 
-    def __rsub__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __rsub__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.SUB, other)
 
-    def __rmul__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __rmul__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.MUL, other)
 
-    def __rtruediv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __rtruediv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.DIV, other)
 
-    def __rmod__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __rmod__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.MOD, other)
 
-    def __rfloordiv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def __rfloordiv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
 
-    def _make_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def _make_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'exprs.ArithmeticExpr':
         """
         other: Union[Expr, LiteralPythonTypes]
         """
@@ -591,10 +592,10 @@ class Expr(abc.ABC):
         if isinstance(other, Expr):
             return ArithmeticExpr(op, self, other)
         if isinstance(other, typing.get_args(LiteralPythonTypes)):
-            return ArithmeticExpr(op, self, Literal(other))  # type: ignore[arg-type]
+            return ArithmeticExpr(op, self, Literal(other))
         raise TypeError(f'Other must be Expr or literal: {type(other)}')
 
-    def _rmake_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+    def _rmake_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'exprs.ArithmeticExpr':
         """
         Right-handed version of _make_arithmetic_expr. other must be a literal; if it were an Expr,
         the operation would have already been evaluated in its left-handed form.
@@ -604,7 +605,7 @@ class Expr(abc.ABC):
         from .literal import Literal
         assert not isinstance(other, Expr)  # Else the left-handed form would have evaluated first
         if isinstance(other, typing.get_args(LiteralPythonTypes)):
-            return ArithmeticExpr(op, Literal(other), self)  # type: ignore[arg-type]
+            return ArithmeticExpr(op, Literal(other), self)
         raise TypeError(f'Other must be Expr or literal: {type(other)}')
 
     def __and__(self, other: object) -> Expr:
@@ -639,7 +640,7 @@ class Expr(abc.ABC):
         else:
             return [], self
 
-    def _make_applicator_function(self, fn: Callable, col_type: Optional[ts.ColumnType]) -> 'pixeltable.func.Function':
+    def _make_applicator_function(self, fn: Callable, col_type: Optional[ts.ColumnType]) -> 'func.Function':
         """
         Creates a unary pixeltable `Function` that encapsulates a python `Callable`. The result type of
         the new `Function` is given by `col_type`, and its parameter type will be `self.col_type`.

pixeltable/exprs/expr_set.py

@@ -66,3 +66,8 @@ class ExprSet(Generic[T]):
 
     def __sub__(self, other: ExprSet[T]) -> ExprSet[T]:
         return self.difference(other)
+
+    def __add__(self, other: ExprSet) -> ExprSet:
+        exprs = self.exprs.copy()
+        exprs.update(other.exprs)
+        return ExprSet(exprs.values())

pixeltable/exprs/function_call.py

@@ -50,14 +50,29 @@ class FunctionCall(Expr):
         if group_by_clause is None:
             group_by_clause = []
         signature = fn.signature
-        super().__init__(fn.call_return_type(bound_args))
+        return_type = fn.call_return_type(bound_args)
         self.fn = fn
         self.is_method_call = is_method_call
         self.normalize_args(fn.name, signature, bound_args)
 
+        # If `return_type` is non-nullable, but the function call has a nullable input to any of its non-nullable
+        # parameters, then we need to make it nullable. This is because Pixeltable defaults a function output to
+        # `None` when any of its non-nullable inputs are `None`.
+        for arg_name, arg in bound_args.items():
+            param = signature.parameters[arg_name]
+            if (
+                param.col_type is not None and not param.col_type.nullable
+                and isinstance(arg, Expr) and arg.col_type.nullable
+            ):
+                return_type = return_type.copy(nullable=True)
+                break
+
+        super().__init__(return_type)
+
         self.agg_init_args = {}
         if self.is_agg_fn_call:
             # we separate out the init args for the aggregator
+            assert isinstance(fn, func.AggregateFunction)
             self.agg_init_args = {
                 arg_name: arg for arg_name, arg in bound_args.items() if arg_name in fn.init_param_names
             }
@@ -71,17 +86,17 @@ class FunctionCall(Expr):
         self.arg_types = []
         self.kwarg_types = {}
         # the prefix of parameters that are bound can be passed by position
-        for param in fn.signature.py_signature.parameters.values():
-            if param.name not in bound_args or param.kind == inspect.Parameter.KEYWORD_ONLY:
+        for py_param in fn.signature.py_signature.parameters.values():
+            if py_param.name not in bound_args or py_param.kind == inspect.Parameter.KEYWORD_ONLY:
                 break
-            arg = bound_args[param.name]
+            arg = bound_args[py_param.name]
             if isinstance(arg, Expr):
                 self.args.append((len(self.components), None))
                 self.components.append(arg.copy())
             else:
                 self.args.append((None, arg))
-            if param.kind != inspect.Parameter.VAR_POSITIONAL and param.kind != inspect.Parameter.VAR_KEYWORD:
-                self.arg_types.append(signature.parameters[param.name].col_type)
+            if py_param.kind != inspect.Parameter.VAR_POSITIONAL and py_param.kind != inspect.Parameter.VAR_KEYWORD:
+                self.arg_types.append(signature.parameters[py_param.name].col_type)
 
         # the remaining args are passed as keywords
         kw_param_names = set(bound_args.keys()) - set(list(fn.signature.py_signature.parameters.keys())[:len(self.args)])
@@ -138,13 +153,11 @@ class FunctionCall(Expr):
         return [RowidRef(target, i) for i in range(target.num_rowid_columns())]
 
     def default_column_name(self) -> Optional[str]:
-        if self.fn.is_property:
-            return self.fn.name
-        return super().default_column_name()
+        return self.fn.name
 
     @classmethod
     def normalize_args(cls, fn_name: str, signature: func.Signature, bound_args: dict[str, Any]) -> None:
-        """Converts all args to Exprs and checks that they are compatible with signature.
+        """Converts args to Exprs where appropriate and checks that they are compatible with signature.
 
         Updates bound_args in place, where necessary.
         """
@@ -263,6 +276,7 @@ class FunctionCall(Expr):
             for param_name, (idx, arg) in self.kwargs.items()
         ])
         if len(self.order_by) > 0:
+            assert isinstance(self.fn, func.AggregateFunction)
             if self.fn.requires_order_by:
                 arg_strs.insert(0, Expr.print_list(self.order_by))
             else:
@@ -273,7 +287,7 @@ class FunctionCall(Expr):
         separator = ', ' if inline else ',\n    '
         return separator.join(arg_strs)
 
-    def has_group_by(self) -> list[Expr]:
+    def has_group_by(self) -> bool:
         return self.group_by_stop_idx != 0
 
     @property
@@ -286,10 +300,11 @@ class FunctionCall(Expr):
 
     @property
     def is_window_fn_call(self) -> bool:
-        return isinstance(self.fn, func.AggregateFunction) and self.fn.allows_window and \
-            (not self.fn.allows_std_agg \
-             or self.has_group_by() \
-             or (len(self.order_by) > 0 and not self.fn.requires_order_by))
+        return isinstance(self.fn, func.AggregateFunction) and self.fn.allows_window and (
+            not self.fn.allows_std_agg
+            or self.has_group_by()
+            or (len(self.order_by) > 0 and not self.fn.requires_order_by)
+        )
 
     def get_window_sort_exprs(self) -> tuple[list[Expr], list[Expr]]:
         return self.group_by, self.order_by
@@ -413,6 +428,7 @@ class FunctionCall(Expr):
             # optimization: avoid additional level of indirection we'd get from calling Function.exec()
             data_row[self.slot_idx] = self.fn.py_fn(*args, **kwargs)
         elif self.is_window_fn_call:
+            assert isinstance(self.fn, func.AggregateFunction)
             if self.has_group_by():
                 if self.current_partition_vals is None:
                     self.current_partition_vals = [None] * len(self.group_by)
@@ -438,7 +454,7 @@ class FunctionCall(Expr):
         return result
 
     @classmethod
-    def _from_dict(cls, d: dict, components: list[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> FunctionCall:
         assert 'fn' in d
         assert 'args' in d
         assert 'kwargs' in d

pixeltable/exprs/globals.py

@@ -5,7 +5,7 @@ import enum
 from typing import Union
 
 # Python types corresponding to our literal types
-LiteralPythonTypes = Union[str, int, float, bool, datetime.datetime, datetime.date]
+LiteralPythonTypes = Union[str, int, float, bool, datetime.datetime]
 
 def print_slice(s: slice) -> str:
     start_str = f'{str(s.start) if s.start is not None else ""}'
@@ -35,6 +35,7 @@ class ComparisonOperator(enum.Enum):
             return '>'
         if self == self.GE:
             return '>='
+        assert False
 
     def reverse(self) -> ComparisonOperator:
         if self == self.LT:
@@ -60,6 +61,7 @@ class LogicalOperator(enum.Enum):
             return '|'
         if self == self.NOT:
             return '~'
+        assert False
 
 
 class ArithmeticOperator(enum.Enum):
@@ -83,3 +85,4 @@ class ArithmeticOperator(enum.Enum):
             return '%'
         if self == self.FLOORDIV:
             return '//'
+        assert False

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])