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

pixeltable/exprs/compound_predicate.py

@@ -1,20 +1,21 @@
 from __future__ import annotations
 
 import operator
-from typing import Optional, List, Any, Dict, Callable
+from typing import Any, Callable, Optional
 
 import sqlalchemy as sql
 
+import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr
 from .globals import LogicalOperator
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
-import pixeltable.type_system as ts
 
 
 class CompoundPredicate(Expr):
-    def __init__(self, operator: LogicalOperator, operands: List[Expr]):
+    def __init__(self, operator: LogicalOperator, operands: list[Expr]):
         super().__init__(ts.BoolType())
         self.operator = operator
         # operands are stored in self.components
@@ -23,7 +24,7 @@ class CompoundPredicate(Expr):
             self.components = operands
         else:
             assert len(operands) > 1
-            self.operands: List[Expr] = []
+            self.operands: list[Expr] = []
             for operand in operands:
                 self._merge_operand(operand)
 
@@ -35,7 +36,7 @@ class CompoundPredicate(Expr):
         return f' {self.operator} '.join([f'({e})' for e in self.components])
 
     @classmethod
-    def make_conjunction(cls, operands: List[Expr]) -> Optional[Expr]:
+    def make_conjunction(cls, operands: list[Expr]) -> Optional[Expr]:
         if len(operands) == 0:
             return None
         if len(operands) == 1:
@@ -89,11 +90,11 @@ class CompoundPredicate(Expr):
                 val = op_function(val, data_row[op.slot_idx])
             data_row[self.slot_idx] = val
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'operator': self.operator.value, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> CompoundPredicate:
         assert 'operator' in d
         return cls(LogicalOperator(d['operator']), components)
 

pixeltable/exprs/data_row.py

@@ -4,13 +4,13 @@ import datetime
 import io
 import urllib.parse
 import urllib.request
-from typing import Optional, List, Any, Tuple
+from typing import Any, Optional
 
-import sqlalchemy as sql
-import pgvector.sqlalchemy
+import numpy as np
+import pgvector.sqlalchemy  # type: ignore[import-untyped]
 import PIL
 import PIL.Image
-import numpy as np
+import sqlalchemy as sql
 
 from pixeltable import env
 
@@ -57,7 +57,7 @@ class DataRow:
     # - None if vals[i] is not a media type or if there is no local file yet for file_urls[i]
     file_paths: list[Optional[str]]
 
-    def __init__(self, size: int, img_slot_idxs: List[int], media_slot_idxs: List[int], array_slot_idxs: List[int]):
+    def __init__(self, size: int, img_slot_idxs: list[int], media_slot_idxs: list[int], array_slot_idxs: list[int]):
         self.vals = [None] * size
         self.has_val = [False] * size
         self.excs = [None] * size
@@ -89,27 +89,35 @@ class DataRow:
         target.file_urls = self.file_urls.copy()
         target.file_paths = self.file_paths.copy()
 
-    def set_pk(self, pk: Tuple[int, ...]) -> None:
+    def set_pk(self, pk: tuple[int, ...]) -> None:
         self.pk = pk
 
-    def has_exc(self, slot_idx: int) -> bool:
-        return self.excs[slot_idx] is not None
+    def has_exc(self, slot_idx: Optional[int] = None) -> bool:
+        """
+        Returns True if an exception has been set for the given slot index, or for any slot index if slot_idx is None
+        """
+        if slot_idx is not None:
+            return self.excs[slot_idx] is not None
+        return any(exc is not None for exc in self.excs)
 
-    def get_exc(self, slot_idx: int) -> Exception:
-        assert self.has_val[slot_idx] is False
-        assert self.excs[slot_idx] is not None
+    def get_exc(self, slot_idx: int) -> Optional[Exception]:
         return self.excs[slot_idx]
 
+    def get_first_exc(self) -> Optional[Exception]:
+        for exc in self.excs:
+            if exc is not None:
+                return exc
+        return None
+
     def set_exc(self, slot_idx: int, exc: Exception) -> None:
         assert self.excs[slot_idx] is None
         self.excs[slot_idx] = exc
 
-        if self.has_val[slot_idx]:
-            # eg. during validation, where contents of file is found invalid
-            self.has_val[slot_idx] = False
-            self.vals[slot_idx] = None
-            self.file_paths[slot_idx] = None
-            self.file_urls[slot_idx] = None
+        # an exception means the value is None
+        self.has_val[slot_idx] = True
+        self.vals[slot_idx] = None
+        self.file_paths[slot_idx] = None
+        self.file_urls[slot_idx] = None
 
     def __len__(self) -> int:
         return len(self.vals)
@@ -124,6 +132,7 @@ class DataRow:
 
         if self.file_urls[index] is not None and index in self.img_slot_idxs:
             # if we need to load this from a file, it should have been materialized locally
+            # TODO this fails if the url was instantiated dynamically using astype()
             assert self.file_paths[index] is not None
             if self.vals[index] is None:
                 self.vals[index] = PIL.Image.open(self.file_paths[index])
@@ -231,7 +240,7 @@ class DataRow:
         self.vals[index] = None
 
     @property
-    def rowid(self) -> Tuple[int]:
+    def rowid(self) -> tuple[int, ...]:
         return self.pk[:-1]
 
     @property

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)