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

pixeltable/exprs/expr.py

@@ -7,13 +7,12 @@ import inspect
 import json
 import sys
 import typing
-from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, TypeVar, Union, overload, Iterable
 from uuid import UUID
 
 import sqlalchemy as sql
-from typing_extensions import Self
+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
@@ -281,29 +274,32 @@ class Expr(abc.ABC):
         """
         Iterate over all subexprs, including self.
         """
-        is_match = filter is None or filter(self)
-        if expr_class is not None:
-            is_match = is_match and isinstance(self, expr_class)
+        is_match = isinstance(self, expr_class) if expr_class is not None else True
+        # apply filter after checking for expr_class
+        if filter is not None and is_match:
+            is_match = filter(self)
         if not is_match or traverse_matches:
             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: list[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."""
@@ -312,13 +308,11 @@ class Expr(abc.ABC):
 
     def _contains(self, cls: Optional[type[Expr]] = None, filter: Optional[Callable[[Expr], bool]] = None) -> bool:
         """
-        Returns True if any subexpr is an instance of cls.
+        Returns True if any subexpr is an instance of cls and/or matches filter.
         """
-        assert (cls is not None) != (filter is not None)  # need one of them
-        if cls is not None:
-            filter = lambda e: isinstance(e, cls)
+        assert cls is not None or filter is not None
         try:
-            _ = next(self.subexprs(filter=filter, traverse_matches=False))
+            _ = next(self.subexprs(expr_class=cls, filter=filter, traverse_matches=False))
             return True
         except StopIteration:
             return False
@@ -330,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]:
@@ -384,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).
@@ -450,18 +441,20 @@ 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: ts.ColumnType) -> 'pixeltable.exprs.TypeCast':
+    def astype(self, new_type: Union[ts.ColumnType, type, _AnnotatedAlias]) -> 'exprs.TypeCast':
         from pixeltable.exprs import TypeCast
-        return TypeCast(self, new_type)
+        return TypeCast(self, ts.ColumnType.normalize_type(new_type))
 
-    def apply(self, fn: Callable, *, col_type: Optional[ts.ColumnType] = 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)
         # Return a `FunctionCall` obtained by passing this `Expr` to the new `function`.
         return function(self)
@@ -474,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
@@ -503,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]
         """
@@ -538,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]
         """
@@ -590,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.
@@ -603,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:
@@ -638,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_dict.py

@@ -0,0 +1,55 @@
+from typing import Generic, TypeVar, Optional, Iterator, Iterable
+
+T = TypeVar('T')
+
+from .expr import Expr
+
+class ExprDict(Generic[T]):
+    """
+    A dictionary that maps Expr instances to values of type T.
+
+    We cannot use dict[Expr, T] because Expr.__eq__() serves a different purpose than the default __eq__.
+    """
+
+    _data: dict[int, tuple[Expr, T]]
+
+    def __init__(self, iterable: Optional[Iterable[tuple[Expr, T]]] = None):
+        self._data = {}
+
+        if iterable is not None:
+            for key, value in iterable:
+                self[key] = value
+
+    def __setitem__(self, key: Expr, value: T) -> None:
+        self._data[key.id] = (key, value)
+
+    def __getitem__(self, key: Expr) -> T:
+        return self._data[key.id][1]
+
+    def __delitem__(self, key: Expr) -> None:
+        del self._data[key.id]
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __iter__(self) -> Iterator[Expr]:
+        return (expr for expr, _ in self._data.values())
+
+    def __contains__(self, key: Expr) -> bool:
+        return key.id in self._data
+
+    def get(self, key: Expr, default: Optional[T] = None) -> Optional[T]:
+        item = self._data.get(key.id)
+        return item[1] if item is not None else default
+
+    def clear(self) -> None:
+        self._data.clear()
+
+    def keys(self) -> Iterator[Expr]:
+        return self.__iter__()
+
+    def values(self) -> Iterator[T]:
+        return (value for _, value in self._data.values())
+
+    def items(self) -> Iterator[tuple[Expr, T]]:
+        return ((expr, value) for expr, value in self._data.values())

pixeltable/exprs/expr_set.py

@@ -1,25 +1,26 @@
 from __future__ import annotations
 
-from typing import Optional, Iterable, Iterator
+from typing import Optional, Iterable, Iterator, TypeVar, Generic
 
 from .expr import Expr
 
+T = TypeVar('T', bound='Expr')
 
-class ExprSet:
+class ExprSet(Generic[T]):
     """
     A set that also supports indexed lookup (by slot_idx and Expr.id). Exprs are uniquely identified by Expr.id.
     """
-    exprs: dict[int, Expr]  # key: Expr.id
-    exprs_by_idx: dict[int, Expr]  # key: slot_idx
+    exprs: dict[int, T]  # key: Expr.id
+    exprs_by_idx: dict[int, T]  # key: slot_idx
 
-    def __init__(self, elements: Optional[Iterable[Expr]] = None):
+    def __init__(self, elements: Optional[Iterable[T]] = None):
         self.exprs = {}
         self.exprs_by_idx = {}
         if elements is not None:
             for e in elements:
                 self.add(e)
 
-    def add(self, expr: Expr) -> None:
+    def add(self, expr: T) -> None:
         if expr.id in self.exprs:
             return
         self.exprs[expr.id] = expr
@@ -27,24 +28,22 @@ class ExprSet:
             return
         self.exprs_by_idx[expr.slot_idx] = expr
 
-    def update(self, *others: Iterable[Expr]) -> None:
+    def update(self, *others: Iterable[T]) -> None:
         for other in others:
             for e in other:
                 self.add(e)
 
-    def __contains__(self, item: Expr) -> bool:
+    def __contains__(self, item: T) -> bool:
         return item.id in self.exprs
 
     def __len__(self) -> int:
         return len(self.exprs)
 
-    def __iter__(self) -> Iterator[Expr]:
+    def __iter__(self) -> Iterator[T]:
         return iter(self.exprs.values())
 
-    def __getitem__(self, index: object) -> Optional[Expr]:
+    def __getitem__(self, index: object) -> Optional[T]:
         """Indexed lookup by slot_idx or Expr.id."""
-        if not isinstance(index, int) and not isinstance(index, Expr):
-            pass
         assert isinstance(index, int) or isinstance(index, Expr)
         if isinstance(index, int):
             # return expr with matching slot_idx
@@ -52,11 +51,23 @@ class ExprSet:
         else:
             return self.exprs.get(index.id)
 
-    def issuperset(self, other: ExprSet) -> bool:
+    def issuperset(self, other: ExprSet[T]) -> bool:
         return self.exprs.keys() >= other.exprs.keys()
 
-    def __ge__(self, other: ExprSet) -> bool:
+    def __ge__(self, other: ExprSet[T]) -> bool:
         return self.issuperset(other)
 
-    def __le__(self, other: ExprSet) -> bool:
+    def __le__(self, other: ExprSet[T]) -> bool:
         return other.issuperset(self)
+
+    def difference(self, *others: Iterable[T]) -> ExprSet[T]:
+        id_diff = set(self.exprs.keys()).difference(e.id for other_set in others for e in other_set)
+        return ExprSet(self.exprs[id] for id in id_diff)
+
+    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,14 +300,19 @@ 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
 
+    def get_window_ordering(self) -> list[tuple[Expr, bool]]:
+        # ordering is implicitly ascending
+        return [(e, None) for e in self.group_by] + [(e, True) for e in self.order_by]
+
     @property
     def is_agg_fn_call(self) -> bool:
         return isinstance(self.fn, func.AggregateFunction)
@@ -303,6 +322,10 @@ class FunctionCall(Expr):
         return self.order_by
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+        # we currently can't translate aggregate functions with grouping and/or ordering to SQL
+        if self.has_group_by() or len(self.order_by) > 0:
+            return None
+
         # try to construct args and kwargs to call self.fn._to_sql()
         kwargs: dict[str, sql.ColumnElement] = {}
         for param_name, (component_idx, arg) in self.kwargs.items():
@@ -374,6 +397,18 @@ class FunctionCall(Expr):
         return args, kwargs
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        if isinstance(self.fn, func.ExprTemplateFunction):
+            # we need to evaluate the template
+            # TODO: can we get rid of this extra copy?
+            fn_expr = self.components[self.fn_expr_idx]
+            data_row[self.slot_idx] = data_row[fn_expr.slot_idx]
+            return
+        elif self.is_agg_fn_call and not self.is_window_fn_call:
+            if self.aggregator is None:
+                pass
+            data_row[self.slot_idx] = self.aggregator.value()
+            return
+
         args, kwargs = self._make_args(data_row)
         signature = self.fn.signature
         if signature.parameters is not None:
@@ -389,15 +424,11 @@ class FunctionCall(Expr):
                     data_row[self.slot_idx] = None
                     return
 
-        if isinstance(self.fn, func.ExprTemplateFunction):
-            # we need to evaluate the template
-            # TODO: can we get rid of this extra copy?
-            fn_expr = self.components[self.fn_expr_idx]
-            data_row[self.slot_idx] = data_row[fn_expr.slot_idx]
-        elif isinstance(self.fn, func.CallableFunction) and not self.fn.is_batched:
+        if isinstance(self.fn, func.CallableFunction) and not self.fn.is_batched:
             # 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)
@@ -410,8 +441,6 @@ class FunctionCall(Expr):
                 self.aggregator = self.fn.agg_cls(**self.agg_init_args)
             self.aggregator.update(*args)
             data_row[self.slot_idx] = self.aggregator.value()
-        elif self.is_agg_fn_call:
-            data_row[self.slot_idx] = self.aggregator.value()
         else:
             data_row[self.slot_idx] = self.fn.exec(*args, **kwargs)
 
@@ -425,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