pixeltable 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

pixeltable/exprs/expr.py

@@ -7,11 +7,12 @@ import inspect
 import json
 import sys
 import typing
-from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, TypeVar, Union, overload, Iterable
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, Optional, TypeVar, Union, overload
 from uuid import UUID
 
+import numpy as np
 import sqlalchemy as sql
-from typing_extensions import _AnnotatedAlias, Self
+from typing_extensions import Self, _AnnotatedAlias
 
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
@@ -24,11 +25,13 @@ from .globals import ArithmeticOperator, ComparisonOperator, LiteralPythonTypes,
 if TYPE_CHECKING:
     from pixeltable import exprs
 
+
 class ExprScope:
     """
     Representation of the scope in which an Expr needs to be evaluated. Used to determine nesting of scopes.
     parent is None: outermost scope
     """
+
     def __init__(self, parent: Optional[ExprScope]):
         self.parent = parent
 
@@ -137,6 +140,9 @@ class Expr(abc.ABC):
         for attr, value in self._id_attrs():
             hasher.update(attr.encode('utf-8'))
             hasher.update(str(value).encode('utf-8'))
+        # Include the col_type of the expression to avoid expressions with identical str() representations
+        # but different types being considered the same expression, e.g. str(int(4)) == "4"
+        hasher.update(repr(self.col_type).encode('utf-8'))
         for expr in self.components:
             hasher.update(str(expr.id).encode('utf-8'))
         # truncate to machine's word size
@@ -183,13 +189,19 @@ class Expr(abc.ABC):
 
     def substitute(self, spec: dict[Expr, Expr]) -> Expr:
         """
-        Replace 'old' with 'new' recursively.
+        Replace 'old' with 'new' recursively, and return a new version of the expression
+        This method must be used in the form: expr = expr.substitute(spec)
         """
+        from .literal import Literal
+
+        if isinstance(self, Literal):
+            return self
         for old, new in spec.items():
             if self.equals(old):
                 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
 
@@ -205,14 +217,18 @@ class Expr(abc.ABC):
         """
         from .column_ref import ColumnRef
         from .expr_set import ExprSet
+
         if resolve_cols is None:
             resolve_cols = set()
         result = self
         while True:
-            target_col_refs = ExprSet([
-                e for e in result.subexprs()
-                if isinstance(e, ColumnRef) and e.col.is_computed and (not e.col.is_stored or e.col in resolve_cols)
-            ])
+            target_col_refs = ExprSet(
+                [
+                    e
+                    for e in result.subexprs()
+                    if isinstance(e, ColumnRef) and e.col.is_computed and (not e.col.is_stored or e.col in resolve_cols)
+                ]
+            )
             if len(target_col_refs) == 0:
                 return result
             result = result.substitute({ref: ref.col.value_expr for ref in target_col_refs})
@@ -220,6 +236,7 @@ class Expr(abc.ABC):
     def is_bound_by(self, tbls: list[catalog.TableVersionPath]) -> bool:
         """Returns True if this expr can be evaluated in the context of tbls."""
         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):
@@ -232,7 +249,7 @@ class Expr(abc.ABC):
         return self._retarget(tbl_versions)
 
     def _retarget(self, tbl_versions: dict[UUID, catalog.TableVersion]) -> Self:
-        for i in range (len(self.components)):
+        for i in range(len(self.components)):
             self.components[i] = self.components[i]._retarget(tbl_versions)
         return self
 
@@ -264,13 +281,14 @@ class Expr(abc.ABC):
 
     @overload
     def subexprs(
-        self, expr_class: type[T], filter: Optional[Callable[[Expr], bool]] = None,
-        traverse_matches: bool = True
+        self, expr_class: type[T], filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
     ) -> Iterator[T]: ...
 
     def subexprs(
-        self, expr_class: Optional[type[T]] = None, filter: Optional[Callable[[Expr], bool]] = None,
-        traverse_matches: bool = True
+        self,
+        expr_class: Optional[type[T]] = None,
+        filter: Optional[Callable[[Expr], bool]] = None,
+        traverse_matches: bool = True,
     ) -> Iterator[T]:
         """
         Iterate over all subexprs, including self.
@@ -288,20 +306,30 @@ class Expr(abc.ABC):
     @overload
     @classmethod
     def list_subexprs(
-        cls, 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(
-        cls, expr_list: Iterable[Expr], expr_class: type[T], filter: Optional[Callable[[Expr], bool]] = None,
-        traverse_matches: bool = True
+        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: Iterable[Expr], expr_class: Optional[type[T]] = None,
-        filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
+        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."""
         for e in expr_list:
@@ -322,6 +350,7 @@ class Expr(abc.ABC):
         """Returns table ids referenced by this expr."""
         from .column_ref import ColumnRef
         from .rowid_ref import RowidRef
+
         return {ref.col.tbl.id for ref in self.subexprs(ColumnRef)} | {ref.tbl.id for ref in self.subexprs(RowidRef)}
 
     @classmethod
@@ -334,6 +363,7 @@ class Expr(abc.ABC):
         result: list[catalog.Column] = []
         assert '_classname' in expr_dict
         from .column_ref import ColumnRef
+
         if expr_dict['_classname'] == 'ColumnRef':
             result.append(ColumnRef.get_column(expr_dict))
         if 'components' in expr_dict:
@@ -341,66 +371,63 @@ class Expr(abc.ABC):
                 result.extend(cls.get_refd_columns(component_dict))
         return result
 
-    def is_constant(self) -> bool:
-        """Returns True if this expr is a constant."""
-        return all(comp.is_constant() for comp in self.components)
-
-    def _as_constant(self) -> Any:
-        return None
-
-    def as_constant(self) -> Any:
+    def as_literal(self) -> Optional[Expr]:
         """
-        If expression is a constant then return the associated value which will be converted to a Literal.
+        Return a Literal expression if this expression can be evaluated to a constant value, otherwise return None.
         """
-        if self.is_constant():
-            return self._as_constant()
         return None
 
     @classmethod
     def from_array(cls, elements: Iterable) -> Optional[Expr]:
         from .inline_expr import InlineArray
+        from .literal import Literal
+
+        if isinstance(elements, np.ndarray):
+            pxttype = ts.ArrayType.from_literal(elements)
+            if pxttype is not None:
+                return Literal(elements, col_type=pxttype)
+
         inline_array = InlineArray(elements)
-        constant_array = inline_array.as_constant()
-        if constant_array is not None:
-            from .literal import Literal
-            return Literal(constant_array, inline_array.col_type)
+        return inline_array.maybe_literal()
+
+    def maybe_literal(self: Expr) -> Expr:
+        """
+        Return a Literal if this expression can be evaluated to a constant value, otherwise return the expression.
+        """
+        lit_expr = self.as_literal()
+        if lit_expr is not None:
+            return lit_expr
         else:
-            return inline_array
+            return self
 
     @classmethod
     def from_object(cls, o: object) -> Optional[Expr]:
         """
         Try to turn a literal object into an Expr.
         """
+        from .inline_expr import InlineDict, InlineList
+        from .literal import Literal
+
         # Try to create a literal. We need to check for InlineList/InlineDict
         # first, to prevent them from inappropriately being interpreted as JsonType
         # literals.
+        if isinstance(o, Literal):
+            return o
+
         if isinstance(o, (list, tuple, dict, Expr)):
-            expr: Optional[Expr] = None
+            expr: Expr
             if isinstance(o, (list, tuple)):
-                from .inline_expr import InlineList
                 expr = InlineList(o)
             elif isinstance(o, dict):
-                from .inline_expr import InlineDict
                 expr = InlineDict(o)
-            elif isinstance(o, Expr):
+            else:
                 expr = o
-                from .literal import Literal
-                if isinstance(expr, Literal):
-                    return expr
-            # Check if the expression is constant
-            if expr is not None:
-                expr_value = expr.as_constant()
-                if expr_value is not None:
-                    from .literal import Literal
-                    return Literal(expr_value)
-                else:
-                    return expr
+
+            return expr.maybe_literal()
         else:
             # convert scalar to a literal
             obj_type = ts.ColumnType.infer_literal_type(o)
             if obj_type is not None:
-                from .literal import Literal
                 return Literal(o, col_type=obj_type)
         return None
 
@@ -444,10 +471,7 @@ class Expr(abc.ABC):
         Turn Expr object into a dict that can be passed to json.dumps().
         Subclasses override _as_dict().
         """
-        return {
-            '_classname': self.__class__.__name__,
-            **self._as_dict(),
-        }
+        return {'_classname': self.__class__.__name__, **self._as_dict()}
 
     @classmethod
     def as_dict_list(self, expr_list: list[Expr]) -> list[dict]:
@@ -485,6 +509,7 @@ class Expr(abc.ABC):
 
     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:
@@ -492,6 +517,7 @@ class Expr(abc.ABC):
 
     def astype(self, new_type: Union[ts.ColumnType, type, _AnnotatedAlias]) -> 'exprs.TypeCast':
         from pixeltable.exprs import TypeCast
+
         # Interpret the type argument the same way we would if given in a schema
         col_type = ts.ColumnType.normalize_type(new_type, nullable_default=True, allow_builtin_types=False)
         if not self.col_type.nullable:
@@ -500,7 +526,9 @@ class Expr(abc.ABC):
             col_type = col_type.copy(nullable=False)
         return TypeCast(self, col_type)
 
-    def apply(self, fn: Callable, *, col_type: Union[ts.ColumnType, type, _AnnotatedAlias, None] = None) -> '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)
@@ -509,10 +537,7 @@ class Expr(abc.ABC):
 
     def __dir__(self) -> list[str]:
         attrs = ['isin', 'astype', 'apply']
-        attrs += [
-            f.name
-            for f in func.FunctionRegistry.get().get_type_methods(self.col_type.type_enum)
-        ]
+        attrs += [f.name for f in func.FunctionRegistry.get().get_type_methods(self.col_type.type_enum)]
         return attrs
 
     def __call__(self, *args: Any, **kwargs: Any) -> Any:
@@ -521,9 +546,11 @@ class Expr(abc.ABC):
     def __getitem__(self, index: object) -> Expr:
         if self.col_type.is_json_type():
             from .json_path import JsonPath
+
             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):
@@ -537,6 +564,7 @@ class Expr(abc.ABC):
         """
         from .json_path import JsonPath
         from .method_ref import MethodRef
+
         if self.col_type.is_json_type():
             return JsonPath(self).__getattr__(name)
         else:
@@ -555,7 +583,8 @@ class Expr(abc.ABC):
 
     def __bool__(self) -> bool:
         raise TypeError(
-            'Pixeltable expressions cannot be used in conjunction with Python boolean operators (and/or/not)')
+            'Pixeltable expressions cannot be used in conjunction with Python boolean operators (and/or/not)'
+        )
 
     def __lt__(self, other: object) -> 'exprs.Comparison':
         return self._make_comparison(ComparisonOperator.LT, other)
@@ -566,6 +595,7 @@ class Expr(abc.ABC):
     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)
 
@@ -573,6 +603,7 @@ class Expr(abc.ABC):
         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)
 
@@ -589,6 +620,7 @@ class Expr(abc.ABC):
         # TODO: check for compatibility
         from .comparison import Comparison
         from .literal import Literal
+
         if isinstance(other, Expr):
             return Comparison(op, self, other)
         if isinstance(other, typing.get_args(LiteralPythonTypes)):
@@ -641,6 +673,7 @@ class Expr(abc.ABC):
         # TODO: check for compatibility
         from .arithmetic_expr import ArithmeticExpr
         from .literal import Literal
+
         if isinstance(other, Expr):
             return ArithmeticExpr(op, self, other)
         if isinstance(other, typing.get_args(LiteralPythonTypes)):
@@ -655,6 +688,7 @@ class Expr(abc.ABC):
         # TODO: check for compatibility
         from .arithmetic_expr import ArithmeticExpr
         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)
@@ -666,6 +700,7 @@ class Expr(abc.ABC):
         if not other.col_type.is_bool_type():
             raise TypeError(f'Other needs to be an expression that returns a boolean: {other.col_type}')
         from .compound_predicate import CompoundPredicate
+
         return CompoundPredicate(LogicalOperator.AND, [self, other])
 
     def __or__(self, other: object) -> Expr:
@@ -674,14 +709,15 @@ class Expr(abc.ABC):
         if not other.col_type.is_bool_type():
             raise TypeError(f'Other needs to be an expression that returns a boolean: {other.col_type}')
         from .compound_predicate import CompoundPredicate
+
         return CompoundPredicate(LogicalOperator.OR, [self, other])
 
     def __invert__(self) -> Expr:
         from .compound_predicate import CompoundPredicate
+
         return CompoundPredicate(LogicalOperator.NOT, [self])
 
-    def split_conjuncts(
-            self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
+    def split_conjuncts(self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
         """
         Returns clauses of a conjunction that meet condition in the first element.
         The second element contains remaining clauses, rolled into a conjunction.
@@ -721,7 +757,8 @@ class Expr(abc.ABC):
         if fn_type is None:
             raise excs.Error(
                 f'Column type of `{fn.__name__}` cannot be inferred. '
-                f'Use `.apply({fn.__name__}, col_type=...)` to specify.')
+                f'Use `.apply({fn.__name__}, col_type=...)` to specify.'
+            )
 
         # TODO(aaron-siegel) Currently we assume that `fn` has exactly one required parameter
         # and all optional parameters take their default values. Should we provide a more
@@ -741,17 +778,15 @@ class Expr(abc.ABC):
             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):
-                raise excs.Error(
-                    f'Function `{fn.__name__}` has no positional parameters.'
-                )
+                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.default == inspect.Parameter.empty:
-                raise excs.Error(
-                    f'Function `{fn.__name__}` has multiple required parameters.'
-                )
+            if (
+                len(params) >= 2
+                and second_param.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+                and second_param.default == inspect.Parameter.empty
+            ):
+                raise excs.Error(f'Function `{fn.__name__}` has multiple required parameters.')
         except ValueError:
             # inspect.signature(fn) will raise a `ValueError` if `fn` is a builtin; I don't
             # know of any way to get the signature of a builtin, nor to check for this in
@@ -765,7 +800,8 @@ class Expr(abc.ABC):
         # We also set the display_name explicitly, so that the `FunctionCall` gets the
         # name of `decorated_fn`, not the lambda.
         return func.make_function(
-            decorated_fn=lambda x: fn(x), return_type=fn_type, param_types=[self.col_type], function_name=fn.__name__)
+            decorated_fn=lambda x: fn(x), return_type=fn_type, param_types=[self.col_type], function_name=fn.__name__
+        )
 
 
 # A dictionary of result types of various stdlib functions that are

pixeltable/exprs/expr_dict.py

@@ -1,9 +1,10 @@
-from typing import Generic, TypeVar, Optional, Iterator, Iterable
+from typing import Generic, Iterable, Iterator, Optional, TypeVar
 
 T = TypeVar('T')
 
 from .expr import Expr
 
+
 class ExprDict(Generic[T]):
     """
     A dictionary that maps Expr instances to values of type T.

pixeltable/exprs/expr_set.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
-from typing import Optional, Iterable, Iterator, TypeVar, Generic
+from typing import Generic, Iterable, Iterator, Optional, TypeVar
 
 from .expr import Expr
 
 T = TypeVar('T', bound='Expr')
 
+
 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, T]  # key: Expr.id
     exprs_by_idx: dict[int, T]  # key: slot_idx
 

pixeltable/exprs/function_call.py

@@ -22,7 +22,6 @@ from .sql_element_cache import SqlElementCache
 
 
 class FunctionCall(Expr):
-
     fn: func.Function
     is_method_call: bool
     agg_init_args: dict[str, Any]
@@ -58,7 +57,7 @@ class FunctionCall(Expr):
         return_type: ts.ColumnType,
         order_by_clause: Optional[list[Any]] = None,
         group_by_clause: Optional[list[Any]] = None,
-        is_method_call: bool = False
+        is_method_call: bool = False,
     ):
         if order_by_clause is None:
             order_by_clause = []
@@ -69,7 +68,7 @@ class FunctionCall(Expr):
 
         self.fn = fn
         self.is_method_call = is_method_call
-        #self.normalize_args(fn.name, signature, bound_args)
+        # self.normalize_args(fn.name, signature, bound_args)
         self.resource_pool = fn.call_resource_pool(bound_args)
         signature = fn.signature
 
@@ -79,8 +78,10 @@ class FunctionCall(Expr):
         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
+                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
@@ -96,7 +97,9 @@ class FunctionCall(Expr):
             self.agg_init_args = {
                 arg_name: arg for arg_name, arg in bound_args.items() if arg_name in fn.init_param_names[0]
             }
-            bound_args = {arg_name: arg for arg_name, arg in bound_args.items() if arg_name not in fn.init_param_names[0]}
+            bound_args = {
+                arg_name: arg for arg_name, arg in bound_args.items() if arg_name not in fn.init_param_names[0]
+            }
 
         # construct components, args, kwargs
         self.args = []
@@ -171,7 +174,8 @@ class FunctionCall(Expr):
         # (that's done in SQL)
         if len(order_by_clause) > 0 and not isinstance(order_by_clause[0], Expr):
             raise excs.Error(
-                f'order_by argument needs to be a Pixeltable expression, but instead is a {type(order_by_clause[0])}')
+                f'order_by argument needs to be a Pixeltable expression, but instead is a {type(order_by_clause[0])}'
+            )
         # don't add components after this, everthing after order_by_start_idx is part of the order_by clause
         self.order_by_start_idx = len(self.components)
         self.components.extend(order_by_clause)
@@ -257,7 +261,8 @@ class FunctionCall(Expr):
                 ):
                     raise excs.Error(
                         f'Parameter {param_name} (in function {fn_name}): argument type {arg.col_type} does not match parameter type '
-                        f'{param.col_type}')
+                        f'{param.col_type}'
+                    )
 
     def _equals(self, other: FunctionCall) -> bool:
         if self.fn != other.fn:
@@ -282,7 +287,7 @@ class FunctionCall(Expr):
             ('kwargs', self.kwargs),
             ('group_by_start_idx', self.group_by_start_idx),
             ('group_by_stop_idx', self.group_by_stop_idx),
-            ('order_by_start_idx', self.order_by_start_idx)
+            ('order_by_start_idx', self.order_by_start_idx),
         ]
 
     def __repr__(self) -> str:
@@ -298,13 +303,14 @@ class FunctionCall(Expr):
     def _print_args(self, start_idx: int = 0, inline: bool = True) -> str:
         def print_arg(arg: Any) -> str:
             return repr(arg) if isinstance(arg, str) else str(arg)
-        arg_strs = [
-            print_arg(arg) if idx is None else str(self.components[idx]) for idx, arg in self.args[start_idx:]
-        ]
-        arg_strs.extend([
-            f'{param_name}={print_arg(arg) if idx is None else str(self.components[idx])}'
-            for param_name, (idx, arg) in self.kwargs.items()
-        ])
+
+        arg_strs = [print_arg(arg) if idx is None else str(self.components[idx]) for idx, arg in self.args[start_idx:]]
+        arg_strs.extend(
+            [
+                f'{param_name}={print_arg(arg) if idx is None else str(self.components[idx])}'
+                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:
@@ -322,18 +328,22 @@ class FunctionCall(Expr):
 
     @property
     def group_by(self) -> list[Expr]:
-        return self.components[self.group_by_start_idx:self.group_by_stop_idx]
+        return self.components[self.group_by_start_idx : self.group_by_stop_idx]
 
     @property
     def order_by(self) -> list[Expr]:
-        return self.components[self.order_by_start_idx:]
+        return self.components[self.order_by_start_idx :]
 
     @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]]:
@@ -435,7 +445,7 @@ class FunctionCall(Expr):
         Returns a list of dicts mapping each param name to its value when this FunctionCall is evaluated against
         data_rows
         """
-        assert all(name in self._param_values for name in param_names)
+        assert all(name in self._param_values for name in param_names), f'{param_names}, {self._param_values.keys()}'
         result: list[dict[str, Any]] = []
         for row in data_rows:
             d: dict[str, Any] = {}
@@ -512,16 +522,12 @@ class FunctionCall(Expr):
         fn = func.Function.from_dict(d['fn'])
         assert not fn.is_polymorphic
         return_type = ts.ColumnType.from_dict(d['return_type']) if 'return_type' in d else None
-        group_by_exprs = components[d['group_by_start_idx']:d['group_by_stop_idx']]
-        order_by_exprs = components[d['order_by_start_idx']:]
+        group_by_exprs = components[d['group_by_start_idx'] : d['group_by_stop_idx']]
+        order_by_exprs = components[d['order_by_start_idx'] :]
 
-        args = [
-            expr if idx is None else components[idx]
-            for idx, expr in d['args']
-        ]
+        args = [expr if idx is None else components[idx] for idx, expr in d['args']]
         kwargs = {
-            param_name: (expr if idx is None else components[idx])
-            for param_name, (idx, expr) in d['kwargs'].items()
+            param_name: (expr if idx is None else components[idx]) for param_name, (idx, expr) in d['kwargs'].items()
         }
 
         # `Function.from_dict()` does signature matching, so it is safe to assume that `args` and `kwargs` are
@@ -538,9 +544,7 @@ class FunctionCall(Expr):
         # for now, as a hack, we do the unpacking here for the specific case of an InlineList of Literals (the only
         # case where this is necessary to support existing conditional_return_type implementations). Once the general
         # pattern is implemented, we can remove this hack.
-        unpacked_bound_args = {
-            param_name: cls.__unpack_bound_arg(arg) for param_name, arg in bound_args.items()
-        }
+        unpacked_bound_args = {param_name: cls.__unpack_bound_arg(arg) for param_name, arg in bound_args.items()}
 
         # Evaluate the call_return_type as defined in the current codebase.
         call_return_type = fn.call_return_type([], unpacked_bound_args)
@@ -567,13 +571,7 @@ class FunctionCall(Expr):
                     f'Return type as currently defined: `{call_return_type}`'
                 )
 
-        fn_call = cls(
-            fn,
-            bound_args,
-            return_type,
-            group_by_clause=group_by_exprs,
-            order_by_clause=order_by_exprs
-        )
+        fn_call = cls(fn, bound_args, return_type, group_by_clause=group_by_exprs, order_by_clause=order_by_exprs)
         return fn_call
 
     @classmethod

pixeltable/exprs/globals.py

@@ -7,6 +7,7 @@ from typing import Union
 # Python types corresponding to our literal types
 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 ""}'
     stop_str = f'{str(s.stop) if s.stop is not None else ""}'