pixeltable 0.2.26__py3-none-any.whl → 0.5.7__py3-none-any.whl

pixeltable/func/aggregate_function.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import abc
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Sequence, overload
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -12,15 +12,15 @@ from .globals import validate_symbol_path
 from .signature import Parameter, Signature
 
 if TYPE_CHECKING:
-    import pixeltable
+    from pixeltable import exprs
 
 
 class Aggregator(abc.ABC):
-    def update(self, *args: Any, **kwargs: Any) -> None:
-        pass
+    @abc.abstractmethod
+    def update(self, *args: Any, **kwargs: Any) -> None: ...
 
-    def value(self) -> Any:
-        pass
+    @abc.abstractmethod
+    def value(self) -> Any: ...
 
 
 class AggregateFunction(Function):
@@ -31,66 +31,149 @@ class AggregateFunction(Function):
     allows_std_agg: if True, the aggregate function can be used as a standard aggregate function w/o a window
     allows_window: if True, the aggregate function can be used with a window
     """
-    ORDER_BY_PARAM = 'order_by'
-    GROUP_BY_PARAM = 'group_by'
-    RESERVED_PARAMS = {ORDER_BY_PARAM, GROUP_BY_PARAM}
+
+    ORDER_BY_PARAM: ClassVar[str] = 'order_by'
+    GROUP_BY_PARAM: ClassVar[str] = 'group_by'
+    RESERVED_PARAMS: ClassVar[set[str]] = {ORDER_BY_PARAM, GROUP_BY_PARAM}
+
+    agg_classes: list[type[Aggregator]]  # classes for each signature, in signature order
+    init_param_names: list[list[str]]  # names of the __init__ parameters for each signature
 
     def __init__(
-            self, aggregator_class: type[Aggregator], self_path: str,
-            init_types: list[ts.ColumnType], update_types: list[ts.ColumnType], value_type: ts.ColumnType,
-            requires_order_by: bool, allows_std_agg: bool, allows_window: bool):
-        self.agg_cls = aggregator_class
+        self,
+        agg_class: type[Aggregator],
+        type_substitutions: Sequence[dict] | None,
+        self_path: str,
+        requires_order_by: bool,
+        allows_std_agg: bool,
+        allows_window: bool,
+    ) -> None:
+        if type_substitutions is None:
+            type_substitutions = [None]  # single signature with no substitutions
+            self.agg_classes = [agg_class]
+        else:
+            self.agg_classes = [agg_class] * len(type_substitutions)
+        self.init_param_names = []
         self.requires_order_by = requires_order_by
         self.allows_std_agg = allows_std_agg
         self.allows_window = allows_window
-        self.__doc__ = aggregator_class.__doc__
+        self.__doc__ = agg_class.__doc__
+
+        signatures: list[Signature] = []
+
+        # If no type_substitutions were provided, construct a single signature for the class.
+        # Otherwise, construct one signature for each type substitution instance.
+        for subst in type_substitutions:
+            signature, init_param_names = self.__cls_to_signature(agg_class, subst)
+            signatures.append(signature)
+            self.init_param_names.append(init_param_names)
+
+        super().__init__(signatures, self_path=self_path)
+
+    def _update_as_overload_resolution(self, signature_idx: int) -> None:
+        self.agg_classes = [self.agg_classes[signature_idx]]
+        self.init_param_names = [self.init_param_names[signature_idx]]
+
+    def __cls_to_signature(
+        self, cls: type[Aggregator], type_substitutions: dict | None = None
+    ) -> tuple[Signature, list[str]]:
+        """Inspects the Aggregator class to infer the corresponding function signature. Returns the
+        inferred signature along with the list of init_param_names (for downstream error handling).
+        """
+        from pixeltable import exprs
+
+        # infer type parameters; set return_type=InvalidType() because it has no meaning here
+        init_sig = Signature.create(
+            py_fn=cls.__init__, return_type=ts.InvalidType(), is_cls_method=True, type_substitutions=type_substitutions
+        )
+        update_sig = Signature.create(
+            py_fn=cls.update, return_type=ts.InvalidType(), is_cls_method=True, type_substitutions=type_substitutions
+        )
+        value_sig = Signature.create(py_fn=cls.value, is_cls_method=True, type_substitutions=type_substitutions)
+
+        init_types = [p.col_type for p in init_sig.parameters.values()]
+        update_types = [p.col_type for p in update_sig.parameters.values()]
+        value_type = value_sig.return_type
+        assert value_type is not None
+
+        if len(update_types) == 0:
+            raise excs.Error('update() must have at least one parameter')
 
         # our signature is the signature of 'update', but without self,
         # plus the parameters of 'init' as keyword-only parameters
-        py_update_params = list(inspect.signature(self.agg_cls.update).parameters.values())[1:]  # leave out self
+        py_update_params = list(inspect.signature(cls.update).parameters.values())[1:]  # leave out self
         assert len(py_update_params) == len(update_types)
         update_params = [
-            Parameter(p.name, col_type=update_types[i], kind=p.kind, default=p.default)
+            Parameter(
+                p.name,
+                col_type=update_types[i],
+                kind=p.kind,
+                default=exprs.Expr.from_object(p.default),  # type: ignore[arg-type]
+            )
             for i, p in enumerate(py_update_params)
         ]
         # starting at 1: leave out self
-        py_init_params = list(inspect.signature(self.agg_cls.__init__).parameters.values())[1:]
+        py_init_params = list(inspect.signature(cls.__init__).parameters.values())[1:]
         assert len(py_init_params) == len(init_types)
         init_params = [
-            Parameter(p.name, col_type=init_types[i], kind=inspect.Parameter.KEYWORD_ONLY, default=p.default)
+            Parameter(
+                p.name,
+                col_type=init_types[i],
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=exprs.Expr.from_object(p.default),  # type: ignore[arg-type]
+            )
             for i, p in enumerate(py_init_params)
         ]
-        duplicate_params = set(p.name for p in init_params) & set(p.name for p in update_params)
+        duplicate_params = {p.name for p in init_params} & {p.name for p in update_params}
         if len(duplicate_params) > 0:
             raise excs.Error(
-                f'__init__() and update() cannot have parameters with the same name: '
-                f'{", ".join(duplicate_params)}'
+                f'__init__() and update() cannot have parameters with the same name: {", ".join(duplicate_params)}'
             )
         params = update_params + init_params  # init_params are keyword-only and come last
+        init_param_names = [p.name for p in init_params]
+
+        return Signature(value_type, params), init_param_names
 
-        signature = Signature(value_type, params)
-        super().__init__(signature, self_path=self_path)
-        self.init_param_names = [p.name for p in init_params]
+    @property
+    def agg_class(self) -> type[Aggregator]:
+        assert not self.is_polymorphic
+        return self.agg_classes[0]
 
-        # make sure the signature doesn't contain reserved parameter names;
-        # do this after super().__init__(), otherwise self.name is invalid
-        for param in signature.parameters:
-            if param.lower() in self.RESERVED_PARAMS:
-                raise excs.Error(f'{self.name}(): parameter name {param} is reserved')
+    @property
+    def is_async(self) -> bool:
+        return False
 
-    def exec(self, *args: Any, **kwargs: Any) -> Any:
+    def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
         raise NotImplementedError
 
+    def overload(self, cls: type[Aggregator]) -> AggregateFunction:
+        if not isinstance(cls, type) or not issubclass(cls, Aggregator):
+            raise excs.Error(f'Invalid argument to @overload decorator: {cls}')
+        if self._has_resolved_fns:
+            raise excs.Error('New `overload` not allowed after the UDF has already been called')
+        if self._conditional_return_type is not None:
+            raise excs.Error('New `overload` not allowed after a conditional return type has been specified')
+        sig, init_param_names = self.__cls_to_signature(cls)
+        self.signatures.append(sig)
+        self.agg_classes.append(cls)
+        self.init_param_names.append(init_param_names)
+        return self
+
+    def comment(self) -> str | None:
+        return inspect.getdoc(self.agg_classes[0])
+
     def help_str(self) -> str:
         res = super().help_str()
-        res += '\n\n' + inspect.getdoc(self.agg_cls.update)
+        # We need to reference agg_classes[0] rather than agg_class here, because we want this to work even if the
+        # aggregator is polymorphic (in which case we use the docstring of the originally decorated UDA).
+        res += '\n\n' + inspect.getdoc(self.agg_classes[0].update)
         return res
 
-    def __call__(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.FunctionCall':
+    def __call__(self, *args: Any, **kwargs: Any) -> 'exprs.FunctionCall':
         from pixeltable import exprs
 
         # perform semantic analysis of special parameters 'order_by' and 'group_by'
-        order_by_clause: Optional[Any] = None
+        order_by_clause: Any | None = None
         if self.ORDER_BY_PARAM in kwargs:
             if self.requires_order_by:
                 raise excs.Error(
@@ -99,7 +182,8 @@ class AggregateFunction(Function):
                 )
             if not self.allows_window:
                 raise excs.Error(
-                    f'{self.display_name}(): order_by invalid with an aggregate function that does not allow windows')
+                    f'{self.display_name}(): order_by invalid with an aggregate function that does not allow windows'
+                )
             order_by_clause = kwargs.pop(self.ORDER_BY_PARAM)
         elif self.requires_order_by:
             # the first argument is the order-by expr
@@ -114,42 +198,61 @@ class AggregateFunction(Function):
             # don't pass the first parameter on, the Function doesn't get to see it
             args = args[1:]
 
-        group_by_clause: Optional[Any] = None
+        group_by_clause: Any | None = None
         if self.GROUP_BY_PARAM in kwargs:
             if not self.allows_window:
                 raise excs.Error(
-                    f'{self.display_name}(): group_by invalid with an aggregate function that does not allow windows')
+                    f'{self.display_name}(): group_by invalid with an aggregate function that does not allow windows'
+                )
             group_by_clause = kwargs.pop(self.GROUP_BY_PARAM)
 
-        bound_args = self.signature.py_signature.bind(*args, **kwargs)
-        self.validate_call(bound_args.arguments)
+        args = [exprs.Expr.from_object(arg) for arg in args]
+        kwargs = {k: exprs.Expr.from_object(v) for k, v in kwargs.items()}
+
+        resolved_fn, bound_args = self._bind_to_matching_signature(args, kwargs)
+        return_type = resolved_fn.call_return_type(bound_args)
+
         return exprs.FunctionCall(
-            self, bound_args.arguments,
+            resolved_fn,
+            args,
+            kwargs,
+            return_type,
             order_by_clause=[order_by_clause] if order_by_clause is not None else [],
-            group_by_clause=[group_by_clause] if group_by_clause is not None else [])
+            group_by_clause=[group_by_clause] if group_by_clause is not None else [],
+        )
+
+    def validate_call(self, bound_args: dict[str, 'exprs.Expr']) -> None:
+        from pixeltable import exprs
+
+        super().validate_call(bound_args)
 
-    def validate_call(self, bound_args: dict[str, Any]) -> None:
         # check that init parameters are not Exprs
         # TODO: do this in the planner (check that init parameters are either constants or only refer to grouping exprs)
-        import pixeltable.exprs as exprs
-        for param_name in self.init_param_names:
-            if param_name in bound_args and isinstance(bound_args[param_name], exprs.Expr):
-                raise excs.Error(
-                    f'{self.display_name}(): init() parameter {param_name} needs to be a constant, not a Pixeltable '
-                    f'expression'
-                )
+        for param_name in self.init_param_names[0]:
+            if param_name in bound_args and not isinstance(bound_args[param_name], exprs.Literal):
+                raise excs.Error(f'{self.display_name}(): init() parameter {param_name!r} must be a constant value')
 
     def __repr__(self) -> str:
         return f'<Pixeltable Aggregator {self.name}>'
 
 
+# Decorator invoked without parentheses: @pxt.uda
+@overload
+def uda(decorated_fn: Callable) -> AggregateFunction: ...
+
+
+# Decorator schema invoked with parentheses: @pxt.uda(**kwargs)
+@overload
 def uda(
-        *,
-        value_type: ts.ColumnType,
-        update_types: list[ts.ColumnType],
-        init_types: Optional[list[ts.ColumnType]] = None,
-        requires_order_by: bool = False, allows_std_agg: bool = True, allows_window: bool = False,
-) -> Callable[[type[Aggregator]], AggregateFunction]:
+    *,
+    requires_order_by: bool = False,
+    allows_std_agg: bool = True,
+    allows_window: bool = False,
+    type_substitutions: Sequence[dict] | None = None,
+) -> Callable[[type[Aggregator]], AggregateFunction]: ...
+
+
+def uda(*args, **kwargs):  # type: ignore[no-untyped-def]
     """Decorator for user-defined aggregate functions.
 
     The decorated class must inherit from Aggregator and implement the following methods:
@@ -161,46 +264,48 @@ def uda(
     to the module where the class is defined.
 
     Parameters:
-    - init_types: list of types for the __init__() parameters; must match the number of parameters
-    - update_types: list of types for the update() parameters; must match the number of parameters
-    - value_type: return type of the aggregator
     - requires_order_by: if True, the first parameter to the function is the order-by expression
     - allows_std_agg: if True, the function can be used as a standard aggregate function w/o a window
     - allows_window: if True, the function can be used with a window
     """
-    if init_types is None:
-        init_types = []
-
-    def decorator(cls: type[Aggregator]) -> AggregateFunction:
-        # validate type parameters
-        num_init_params = len(inspect.signature(cls.__init__).parameters) - 1
-        if num_init_params > 0:
-            if len(init_types) != num_init_params:
-                raise excs.Error(
-                    f'init_types must be a list of {num_init_params} types, one for each parameter of __init__()')
-        num_update_params = len(inspect.signature(cls.update).parameters) - 1
-        if num_update_params == 0:
-            raise excs.Error('update() must have at least one parameter')
-        if len(update_types) != num_update_params:
-            raise excs.Error(
-                f'update_types must be a list of {num_update_params} types, one for each parameter of update()')
-        assert value_type is not None
-
-        # the AggregateFunction instance resides in the same module as cls
-        class_path = f'{cls.__module__}.{cls.__qualname__}'
-        # nonlocal name
-        # name = name or cls.__name__
-        # instance_path_elements = class_path.split('.')[:-1] + [name]
-        # instance_path = '.'.join(instance_path_elements)
-
-        # create the corresponding AggregateFunction instance
-        instance = AggregateFunction(
-            cls, class_path, init_types, update_types, value_type, requires_order_by, allows_std_agg, allows_window)
-        # do the path validation at the very end, in order to be able to write tests for the other failure cases
-        validate_symbol_path(class_path)
-        #module = importlib.import_module(cls.__module__)
-        #setattr(module, name, instance)
-
-        return instance
+    if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+        # Decorator invoked without parentheses: @pxt.uda
+        # Simply call make_aggregator with defaults.
+        return make_aggregator(cls=args[0])
+
+    else:
+        # Decorator schema invoked with parentheses: @pxt.uda(**kwargs)
+        # Create a decorator for the specified schema.
+        requires_order_by = kwargs.pop('requires_order_by', False)
+        allows_std_agg = kwargs.pop('allows_std_agg', True)
+        allows_window = kwargs.pop('allows_window', False)
+        type_substitutions = kwargs.pop('type_substitutions', None)
+        if len(kwargs) > 0:
+            raise excs.Error(f'Invalid @uda decorator kwargs: {", ".join(kwargs.keys())}')
+        if len(args) > 0:
+            raise excs.Error('Unexpected @uda decorator arguments.')
+
+        def decorator(cls: type[Aggregator]) -> AggregateFunction:
+            return make_aggregator(
+                cls,
+                requires_order_by=requires_order_by,
+                allows_std_agg=allows_std_agg,
+                allows_window=allows_window,
+                type_substitutions=type_substitutions,
+            )
 
-    return decorator
+        return decorator
+
+
+def make_aggregator(
+    cls: type[Aggregator],
+    requires_order_by: bool = False,
+    allows_std_agg: bool = True,
+    allows_window: bool = False,
+    type_substitutions: Sequence[dict] | None = None,
+) -> AggregateFunction:
+    class_path = f'{cls.__module__}.{cls.__qualname__}'
+    instance = AggregateFunction(cls, type_substitutions, class_path, requires_order_by, allows_std_agg, allows_window)
+    # do the path validation at the very end, in order to be able to write tests for the other failure cases
+    validate_symbol_path(class_path)
+    return instance

pixeltable/func/callable_function.py

@@ -1,14 +1,20 @@
 from __future__ import annotations
 
 import inspect
-from typing import Any, Callable, Optional
+from typing import TYPE_CHECKING, Any, Callable, Sequence
 from uuid import UUID
 
 import cloudpickle  # type: ignore[import-untyped]
 
+import pixeltable.exceptions as excs
+from pixeltable.utils.coroutine import run_coroutine_synchronously
+
 from .function import Function
 from .signature import Signature
 
+if TYPE_CHECKING:
+    from pixeltable import exprs
+
 
 class CallableFunction(Function):
     """Pixeltable Function backed by a Python Callable.
@@ -18,55 +24,121 @@ class CallableFunction(Function):
     - functions that are defined in modules are serialized via the default mechanism
     """
 
+    py_fns: list[Callable]
+    self_name: str | None
+    batch_size: int | None
+
     def __init__(
         self,
-        signature: Signature,
-        py_fn: Callable,
-        self_path: Optional[str] = None,
-        self_name: Optional[str] = None,
-        batch_size: Optional[int] = None,
+        signatures: list[Signature],
+        py_fns: list[Callable],
+        self_path: str | None = None,
+        self_name: str | None = None,
+        batch_size: int | None = None,
         is_method: bool = False,
-        is_property: bool = False
+        is_property: bool = False,
     ):
-        assert py_fn is not None
-        self.py_fn = py_fn
+        assert len(signatures) > 0
+        assert len(signatures) == len(py_fns)
+        if self_path is None and len(signatures) > 1:
+            raise excs.Error('Multiple signatures are only allowed for module UDFs (not locally defined UDFs)')
+        self.py_fns = py_fns
         self.self_name = self_name
         self.batch_size = batch_size
-        self.__doc__ = py_fn.__doc__
-        super().__init__(signature, self_path=self_path, is_method=is_method, is_property=is_property)
+        self.__doc__ = self.py_fns[0].__doc__
+        super().__init__(signatures, self_path=self_path, is_method=is_method, is_property=is_property)
+
+    def _update_as_overload_resolution(self, signature_idx: int) -> None:
+        assert len(self.py_fns) > signature_idx
+        self.py_fns = [self.py_fns[signature_idx]]
 
     @property
     def is_batched(self) -> bool:
         return self.batch_size is not None
 
-    def exec(self, *args: Any, **kwargs: Any) -> Any:
+    @property
+    def is_async(self) -> bool:
+        return inspect.iscoroutinefunction(self.py_fn)
+
+    def comment(self) -> str | None:
+        return inspect.getdoc(self.py_fns[0])
+
+    @property
+    def py_fn(self) -> Callable:
+        assert not self.is_polymorphic
+        return self.py_fns[0]
+
+    async def aexec(self, *args: Any, **kwargs: Any) -> Any:
+        assert not self.is_polymorphic
+        assert self.is_async
+        if self.is_batched:
+            # Pack the batched parameters into singleton lists
+            constant_param_names = [p.name for p in self.signature.constant_parameters]
+            batched_args = [[arg] for arg in args]
+            constant_kwargs = {k: v for k, v in kwargs.items() if k in constant_param_names}
+            batched_kwargs = {k: [v] for k, v in kwargs.items() if k not in constant_param_names}
+            result = await self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
+            assert len(result) == 1
+            return result[0]
+        else:
+            return await self.py_fn(*args, **kwargs)
+
+    def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
+        assert not self.is_polymorphic
         if self.is_batched:
             # Pack the batched parameters into singleton lists
             constant_param_names = [p.name for p in self.signature.constant_parameters]
             batched_args = [[arg] for arg in args]
             constant_kwargs = {k: v for k, v in kwargs.items() if k in constant_param_names}
             batched_kwargs = {k: [v] for k, v in kwargs.items() if k not in constant_param_names}
-            result = self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
+            result: list[Any]
+            if inspect.iscoroutinefunction(self.py_fn):
+                # TODO: This is temporary (see note in utils/coroutine.py)
+                result = run_coroutine_synchronously(self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs))
+            else:
+                result = self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
             assert len(result) == 1
             return result[0]
+        elif inspect.iscoroutinefunction(self.py_fn):
+            # TODO: This is temporary (see note in utils/coroutine.py)
+            return run_coroutine_synchronously(self.py_fn(*args, **kwargs))
         else:
             return self.py_fn(*args, **kwargs)
 
-    def exec_batch(self, *args: Any, **kwargs: Any) -> list:
+    async def aexec_batch(self, *args: Any, **kwargs: Any) -> list:
         """Execute the function with the given arguments and return the result.
         The arguments are expected to be batched: if the corresponding parameter has type T,
         then the argument should have type T if it's a constant parameter, or list[T] if it's
         a batched parameter.
         """
         assert self.is_batched
+        assert self.is_async
+        assert not self.is_polymorphic
         # Unpack the constant parameters
+        constant_kwargs, batched_kwargs = self.create_batch_kwargs(kwargs)
+        return await self.py_fn(*args, **constant_kwargs, **batched_kwargs)
+
+    def exec_batch(self, args: list[Any], kwargs: dict[str, Any]) -> list:
+        """Execute the function with the given arguments and return the result.
+        The arguments are expected to be batched: if the corresponding parameter has type T,
+        then the argument should have type T if it's a constant parameter, or list[T] if it's
+        a batched parameter.
+        """
+        assert self.is_batched
+        assert not self.is_polymorphic
+        assert not self.is_async
+        # Unpack the constant parameters
+        constant_kwargs, batched_kwargs = self.create_batch_kwargs(kwargs)
+        return self.py_fn(*args, **constant_kwargs, **batched_kwargs)
+
+    def create_batch_kwargs(self, kwargs: dict[str, Any]) -> tuple[dict[str, Any], dict[str, list[Any]]]:
+        """Converts kwargs containing lists into constant and batched kwargs in the format expected by a batched udf."""
         constant_param_names = [p.name for p in self.signature.constant_parameters]
         constant_kwargs = {k: v[0] for k, v in kwargs.items() if k in constant_param_names}
         batched_kwargs = {k: v for k, v in kwargs.items() if k not in constant_param_names}
-        return self.py_fn(*args, **constant_kwargs, **batched_kwargs)
+        return constant_kwargs, batched_kwargs
 
-    # TODO(aaron-siegel): Implement conditional batch sizing
-    def get_batch_size(self, *args: Any, **kwargs: Any) -> Optional[int]:
+    def get_batch_size(self, *args: Any, **kwargs: Any) -> int | None:
         return self.batch_size
 
     @property
@@ -77,16 +149,26 @@ class CallableFunction(Function):
     def name(self) -> str:
         return self.self_name
 
-    def help_str(self) -> str:
-        res = super().help_str()
-        res += '\n\n' + inspect.getdoc(self.py_fn)
-        return res
+    def overload(self, fn: Callable) -> CallableFunction:
+        if self.self_path is None:
+            raise excs.Error('`overload` can only be used with module UDFs (not locally defined UDFs)')
+        if self.is_method or self.is_property:
+            raise excs.Error('`overload` cannot be used with `is_method` or `is_property`')
+        if self._has_resolved_fns:
+            raise excs.Error('New `overload` not allowed after the UDF has already been called')
+        if self._conditional_return_type is not None:
+            raise excs.Error('New `overload` not allowed after a conditional return type has been specified')
+        sig = Signature.create(fn)
+        self.signatures.append(sig)
+        self.py_fns.append(fn)
+        return self
 
     def _as_dict(self) -> dict:
         if self.self_path is None:
             # this is not a module function
             assert not self.is_method and not self.is_property
             from .function_registry import FunctionRegistry
+
             id = FunctionRegistry.get().create_stored_function(self)
             return {'id': id.hex}
         return super()._as_dict()
@@ -95,33 +177,35 @@ class CallableFunction(Function):
     def _from_dict(cls, d: dict) -> Function:
         if 'id' in d:
             from .function_registry import FunctionRegistry
+
             return FunctionRegistry.get().get_stored_function(UUID(hex=d['id']))
         return super()._from_dict(d)
 
     def to_store(self) -> tuple[dict, bytes]:
-        md = {
-            'signature': self.signature.as_dict(),
-            'batch_size': self.batch_size,
-        }
+        assert not self.is_polymorphic  # multi-signature UDFs not allowed for stored fns
+        md = {'signature': self.signature.as_dict(), 'batch_size': self.batch_size}
         return md, cloudpickle.dumps(self.py_fn)
 
     @classmethod
-    def from_store(cls, name: Optional[str], md: dict, binary_obj: bytes) -> Function:
+    def from_store(cls, name: str | None, md: dict, binary_obj: bytes) -> Function:
         py_fn = cloudpickle.loads(binary_obj)
         assert callable(py_fn)
         sig = Signature.from_dict(md['signature'])
         batch_size = md['batch_size']
-        return CallableFunction(sig, py_fn, self_name=name, batch_size=batch_size)
+        return CallableFunction([sig], [py_fn], self_name=name, batch_size=batch_size)
+
+    def validate_call(self, bound_args: dict[str, 'exprs.Expr']) -> None:
+        from pixeltable import exprs
 
-    def validate_call(self, bound_args: dict[str, Any]) -> None:
-        import pixeltable.exprs as exprs
+        super().validate_call(bound_args)
         if self.is_batched:
-            for param in self.signature.constant_parameters:
-                if param.name in bound_args and isinstance(bound_args[param.name], exprs.Expr):
-                    raise ValueError(
-                        f'{self.display_name}(): '
-                        f'parameter {param.name} must be a constant value, not a Pixeltable expression'
-                    )
+            signature = self.signatures[0]
+            for param in signature.constant_parameters:
+                # Check that constant parameters map to constant arguments. It's ok for the argument to be a Variable,
+                # since in that case the FunctionCall is part of an unresolved template; the check will be done again
+                # when the template is fully resolved.
+                if param.name in bound_args and not isinstance(bound_args[param.name], (exprs.Literal, exprs.Variable)):
+                    raise ValueError(f'{self.display_name}(): parameter {param.name} must be a constant value')
 
     def __repr__(self) -> str:
         return f'<Pixeltable UDF {self.name}>'