pixeltable 0.2.28__py3-none-any.whl → 0.2.29__py3-none-any.whl

pixeltable/func/callable_function.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 import inspect
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Sequence
 from uuid import UUID
 
 import cloudpickle  # type: ignore[import-untyped]
 
+import pixeltable.exceptions as excs
+
 from .function import Function
 from .signature import Signature
 
@@ -20,26 +22,39 @@ class CallableFunction(Function):
 
     def __init__(
         self,
-        signature: Signature,
-        py_fn: Callable,
+        signatures: list[Signature],
+        py_fns: list[Callable],
         self_path: Optional[str] = None,
         self_name: Optional[str] = None,
         batch_size: Optional[int] = None,
         is_method: 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 py_fn(self) -> Callable:
+        assert not self.is_polymorphic
+        return self.py_fns[0]
+
+    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]
@@ -52,13 +67,14 @@ class CallableFunction(Function):
         else:
             return self.py_fn(*args, **kwargs)
 
-    def exec_batch(self, *args: Any, **kwargs: Any) -> list:
+    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
         # Unpack the constant parameters
         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}
@@ -77,9 +93,25 @@ class CallableFunction(Function):
     def name(self) -> str:
         return self.self_name
 
+    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_batched:
+            raise excs.Error('`overload` cannot be used with batched functions')
+        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 help_str(self) -> str:
         res = super().help_str()
-        res += '\n\n' + inspect.getdoc(self.py_fn)
+        res += '\n\n' + inspect.getdoc(self.py_fns[0])
         return res
 
     def _as_dict(self) -> dict:
@@ -99,6 +131,7 @@ class CallableFunction(Function):
         return super()._from_dict(d)
 
     def to_store(self) -> tuple[dict, bytes]:
+        assert not self.is_polymorphic  # multi-signature UDFs not allowed for stored fns
         md = {
             'signature': self.signature.as_dict(),
             'batch_size': self.batch_size,
@@ -111,12 +144,15 @@ class CallableFunction(Function):
         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, Any]) -> None:
-        import pixeltable.exprs as exprs
+        from pixeltable import exprs
+
+        assert not self.is_polymorphic
         if self.is_batched:
-            for param in self.signature.constant_parameters:
+            signature = self.signatures[0]
+            for param in signature.constant_parameters:
                 if param.name in bound_args and isinstance(bound_args[param.name], exprs.Expr):
                     raise ValueError(
                         f'{self.display_name}(): '

pixeltable/func/expr_template_function.py

@@ -1,5 +1,5 @@
 import inspect
-from typing import Any, Optional
+from typing import Any, Optional, Sequence
 
 import pixeltable
 import pixeltable.exceptions as excs
@@ -8,15 +8,22 @@ from .function import Function
 from .signature import Signature
 
 
-class ExprTemplateFunction(Function):
-    """A parameterized expression from which an executable Expr is created with a function call."""
+class ExprTemplate:
+    """
+    Encapsulates a single signature of an `ExprTemplateFunction` and its associated parameterized expression,
+    along with various precomputed metadata. (This is analogous to a `Callable`-`Signature` pair in a
+    `CallableFunction`.)
+    """
+    expr: 'pixeltable.exprs.Expr'
+    signature: Signature
+    param_exprs: list['pixeltable.exprs.Variable']
+
+    def __init__(self, expr: 'pixeltable.exprs.Expr', signature: Signature):
+        from pixeltable import exprs
 
-    def __init__(
-            self, expr: 'pixeltable.exprs.Expr', signature: Signature, self_path: Optional[str] = None,
-            name: Optional[str] = None):
-        import pixeltable.exprs as exprs
         self.expr = expr
-        self.self_name = name
+        self.signature = signature
+
         self.param_exprs = list(set(expr.subexprs(expr_class=exprs.Variable)))
         # make sure there are no duplicate names
         assert len(self.param_exprs) == len(set(p.name for p in self.param_exprs))
@@ -24,7 +31,7 @@ class ExprTemplateFunction(Function):
 
         # verify default values
         self.defaults: dict[str, exprs.Literal] = {}  # key: param name, value: default value converted to a Literal
-        for param in signature.parameters.values():
+        for param in self.signature.parameters.values():
             if param.default is inspect.Parameter.empty:
                 continue
             param_expr = self.param_exprs_by_name[param.name]
@@ -35,18 +42,39 @@ class ExprTemplateFunction(Function):
                 msg = str(e)
                 raise excs.Error(f"Default value for parameter '{param.name}': {msg[0].lower() + msg[1:]}")
 
-        super().__init__(signature, self_path=self_path)
 
-    def instantiate(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.Expr':
+class ExprTemplateFunction(Function):
+    """A parameterized expression from which an executable Expr is created with a function call."""
+    templates: list[ExprTemplate]
+    self_name: str
+
+    def __init__(self, templates: list[ExprTemplate], self_path: Optional[str] = None, name: Optional[str] = None):
+        self.templates = templates
+        self.self_name = name
+
+        super().__init__([t.signature for t in templates], self_path=self_path)
+
+    def _update_as_overload_resolution(self, signature_idx: int) -> None:
+        self.templates = [self.templates[signature_idx]]
+
+    @property
+    def template(self) -> ExprTemplate:
+        assert not self.is_polymorphic
+        return self.templates[0]
+
+    def instantiate(self, args: Sequence[Any], kwargs: dict[str, Any]) -> 'pixeltable.exprs.Expr':
+        from pixeltable import exprs
+
+        assert not self.is_polymorphic
+        template = self.template
         bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
         # apply defaults, otherwise we might have Parameters left over
         bound_args.update(
-            {param_name: default for param_name, default in self.defaults.items() if param_name not in bound_args})
-        result = self.expr.copy()
-        import pixeltable.exprs as exprs
+            {param_name: default for param_name, default in template.defaults.items() if param_name not in bound_args})
+        result = template.expr.copy()
         arg_exprs: dict[exprs.Expr, exprs.Expr] = {}
         for param_name, arg in bound_args.items():
-            param_expr = self.param_exprs_by_name[param_name]
+            param_expr = template.param_exprs_by_name[param_name]
             if not isinstance(arg, exprs.Expr):
                 # TODO: use the available param_expr.col_type
                 arg_expr = exprs.Expr.from_object(arg)
@@ -56,15 +84,15 @@ class ExprTemplateFunction(Function):
                 arg_expr = arg
             arg_exprs[param_expr] = arg_expr
         result = result.substitute(arg_exprs)
-        import pixeltable.exprs as exprs
         assert not result._contains(exprs.Variable)
         return result
 
-    def exec(self, *args: Any, **kwargs: Any) -> Any:
-        expr = self.instantiate(*args, **kwargs)
-        import pixeltable.exprs as exprs
+    def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
+        from pixeltable import exec, exprs
+
+        assert not self.is_polymorphic
+        expr = self.instantiate(args, kwargs)
         row_builder = exprs.RowBuilder(output_exprs=[expr], columns=[], input_exprs=[])
-        import pixeltable.exec as exec
         row_batch = exec.DataRowBatch(tbl=None, row_builder=row_builder, len=1)
         row = row_batch[0]
         row_builder.eval(row, ctx=row_builder.default_eval_ctx)
@@ -79,13 +107,15 @@ class ExprTemplateFunction(Function):
         return self.self_name
 
     def __str__(self) -> str:
-        return str(self.expr)
+        return str(self.templates[0].expr)
 
     def _as_dict(self) -> dict:
         if self.self_path is not None:
             return super()._as_dict()
+        assert not self.is_polymorphic
+        assert len(self.templates) == 1
         return {
-            'expr': self.expr.as_dict(),
+            'expr': self.template.expr.as_dict(),
             'signature': self.signature.as_dict(),
             'name': self.name,
         }
@@ -93,7 +123,8 @@ class ExprTemplateFunction(Function):
     @classmethod
     def _from_dict(cls, d: dict) -> Function:
         if 'expr' not in d:
-            return super()._from_dict(d)
+             return super()._from_dict(d)
         assert 'signature' in d and 'name' in d
         import pixeltable.exprs as exprs
-        return cls(exprs.Expr.from_dict(d['expr']), Signature.from_dict(d['signature']), name=d['name'])
+        template = ExprTemplate(exprs.Expr.from_dict(d['expr']), Signature.from_dict(d['signature']))
+        return cls([template], name=d['name'])

pixeltable/func/function.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 import abc
 import importlib
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from copy import copy
+from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, cast
 
 import sqlalchemy as sql
+from typing_extensions import Self
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
@@ -15,7 +17,7 @@ from .globals import resolve_symbol
 from .signature import Signature
 
 if TYPE_CHECKING:
-    from .expr_template_function import ExprTemplateFunction
+    from .expr_template_function import ExprTemplate, ExprTemplateFunction
 
 
 class Function(abc.ABC):
@@ -26,30 +28,42 @@ class Function(abc.ABC):
     via the member self_path.
     """
 
-    signature: Signature
+    signatures: list[Signature]
     self_path: Optional[str]
     is_method: bool
     is_property: bool
     _conditional_return_type: Optional[Callable[..., ts.ColumnType]]
 
+    # We cache the overload resolutions in self._resolutions. This ensures that each resolution is represented
+    # globally by a single Python object. We do this dynamically rather than pre-constructing them in order to
+    # avoid circular complexity in the `Function` initialization logic.
+    __resolved_fns: list[Self]
+
     # Translates a call to this function with the given arguments to its SQLAlchemy equivalent.
     # Overriden for specific Function instances via the to_sql() decorator. The override must accept the same
     # parameter names as the original function. Each parameter is going to be of type sql.ColumnElement.
     _to_sql: Callable[..., Optional[sql.ColumnElement]]
 
-
     def __init__(
-        self, signature: Signature, self_path: Optional[str] = None, is_method: bool = False, is_property: bool = False
+        self,
+        signatures: list[Signature],
+        self_path: Optional[str] = None,
+        is_method: bool = False,
+        is_property: bool = False
     ):
         # Check that stored functions cannot be declared using `is_method` or `is_property`:
         assert not ((is_method or is_property) and self_path is None)
-        self.signature = signature
+        assert isinstance(signatures, list)
+        assert len(signatures) > 0
+        self.signatures = signatures
         self.self_path = self_path  # fully-qualified path to self
         self.is_method = is_method
         self.is_property = is_property
         self._conditional_return_type = None
         self._to_sql = self.__default_to_sql
 
+        self.__resolved_fns = []
+
     @property
     def name(self) -> str:
         assert self.self_path is not None
@@ -64,37 +78,121 @@ class Function(abc.ABC):
             return self.self_path[len(ptf_prefix):]
         return self.self_path
 
+    @property
+    def is_polymorphic(self) -> bool:
+        return len(self.signatures) > 1
+
+    @property
+    def signature(self) -> Signature:
+        assert not self.is_polymorphic
+        return self.signatures[0]
+
     @property
     def arity(self) -> int:
+        assert not self.is_polymorphic
         return len(self.signature.parameters)
 
+    @property
+    def _resolved_fns(self) -> list[Self]:
+        """
+        Return the list of overload resolutions for this `Function`, constructing it first if necessary.
+        Each resolution is a new `Function` instance that retains just the single signature at index `signature_idx`,
+        and is otherwise identical to this `Function`.
+        """
+        if len(self.__resolved_fns) == 0:
+            # The list of overload resolutions hasn't been constructed yet; do so now.
+            if len(self.signatures) == 1:
+                # Only one signature: no need to construct separate resolutions
+                self.__resolved_fns.append(self)
+            else:
+                # Multiple signatures: construct a resolution for each signature
+                for idx in range(len(self.signatures)):
+                    resolution = cast(Self, copy(self))
+                    resolution.signatures = [self.signatures[idx]]
+                    resolution._update_as_overload_resolution(idx)
+                    self.__resolved_fns.append(resolution)
+
+        return self.__resolved_fns
+
+    @property
+    def _has_resolved_fns(self) -> bool:
+        """
+        Returns true if the resolved_fns for this `Function` have been constructed (i.e., if self._resolved_fns
+        has been accessed).
+        """
+        return len(self.__resolved_fns) > 0
+
+    def _update_as_overload_resolution(self, signature_idx: int) -> None:
+        """
+        Subclasses must implement this in order to do any additional work when creating a resolution, beyond
+        simply updating `self.signatures`.
+        """
+        raise NotImplementedError()
+
     def help_str(self) -> str:
-        return self.display_name + str(self.signature)
+        return self.display_name + str(self.signatures[0])
 
     def __call__(self, *args: Any, **kwargs: Any) -> 'pxt.exprs.FunctionCall':
         from pixeltable import exprs
-        bound_args = self.signature.py_signature.bind(*args, **kwargs)
-        self.validate_call(bound_args.arguments)
-        return exprs.FunctionCall(self, bound_args.arguments)
+
+        resolved_fn, bound_args = self._bind_to_matching_signature(args, kwargs)
+        return_type = resolved_fn.call_return_type(args, kwargs)
+        return exprs.FunctionCall(resolved_fn, bound_args, return_type)
+
+    def _bind_to_matching_signature(self, args: Sequence[Any], kwargs: dict[str, Any]) -> tuple[Self, dict[str, Any]]:
+        result: int = -1
+        bound_args: Optional[dict[str, Any]] = None
+        assert len(self.signatures) > 0
+        if len(self.signatures) == 1:
+            # Only one signature: call _bind_to_signature() and surface any errors directly
+            result = 0
+            bound_args = self._bind_to_signature(0, args, kwargs)
+        else:
+            # Multiple signatures: try each signature in declaration order and trap any errors.
+            # If none of them succeed, raise a generic error message.
+            for i in range(len(self.signatures)):
+                try:
+                    bound_args = self._bind_to_signature(i, args, kwargs)
+                except (TypeError, excs.Error):
+                    continue
+                result = i
+                break
+            if result == -1:
+                raise excs.Error(f'Function {self.name!r} has no matching signature for arguments')
+        assert result >= 0
+        assert bound_args is not None
+        return self._resolved_fns[result], bound_args
+
+    def _bind_to_signature(self, signature_idx: int, args: Sequence[Any], kwargs: dict[str, Any]) -> dict[str, Any]:
+        from pixeltable import exprs
+
+        signature = self.signatures[signature_idx]
+        bound_args = signature.py_signature.bind(*args, **kwargs).arguments
+        self._resolved_fns[signature_idx].validate_call(bound_args)
+        exprs.FunctionCall.normalize_args(self.name, signature, bound_args)
+        return bound_args
 
     def validate_call(self, bound_args: dict[str, Any]) -> None:
         """Override this to do custom validation of the arguments"""
-        pass
+        assert not self.is_polymorphic
 
-    def call_return_type(self, kwargs: dict[str, Any]) -> ts.ColumnType:
+    def call_return_type(self, args: Sequence[Any], kwargs: dict[str, Any]) -> ts.ColumnType:
         """Return the type of the value returned by calling this function with the given arguments"""
+        assert not self.is_polymorphic
         if self._conditional_return_type is None:
             return self.signature.return_type
-        bound_args = self.signature.py_signature.bind(**kwargs)
+        bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
         kw_args: dict[str, Any] = {}
         sig = inspect.signature(self._conditional_return_type)
         for param in sig.parameters.values():
-            if param.name in bound_args.arguments:
-                kw_args[param.name] = bound_args.arguments[param.name]
+            if param.name in bound_args:
+                kw_args[param.name] = bound_args[param.name]
         return self._conditional_return_type(**kw_args)
 
     def conditional_return_type(self, fn: Callable[..., ts.ColumnType]) -> Callable[..., ts.ColumnType]:
         """Instance decorator for specifying a conditional return type for this function"""
+        if self.is_polymorphic:
+            raise excs.Error('`conditional_return_type` is not supported for functions with multiple signatures')
         # verify that call_return_type only has parameters that are also present in the signature
         sig = inspect.signature(fn)
         for param in sig.parameters.values():
@@ -104,9 +202,35 @@ class Function(abc.ABC):
         return fn
 
     def using(self, **kwargs: Any) -> 'ExprTemplateFunction':
+        from .expr_template_function import ExprTemplateFunction
+
+        assert len(self.signatures) > 0
+        if len(self.signatures) == 1:
+            # Only one signature: call _bind_and_create_template() and surface any errors directly
+            template = self._bind_and_create_template(kwargs)
+            return ExprTemplateFunction([template])
+        else:
+            # Multiple signatures: iterate over each signature and generate a template for each
+            # successful binding. If there are no successful bindings, raise a generic error.
+            # (Note that the resulting ExprTemplateFunction may have strictly fewer signatures than
+            # this Function, in the event that only some of the signatures are successfully bound.)
+            templates: list['ExprTemplate'] = []
+            for i in range(len(self.signatures)):
+                try:
+                    template = self._resolved_fns[i]._bind_and_create_template(kwargs)
+                    templates.append(template)
+                except (TypeError, excs.Error):
+                    continue
+            if len(templates) == 0:
+                raise excs.Error(f'Function {self.name!r} has no matching signature for arguments')
+            return ExprTemplateFunction(templates)
+
+    def _bind_and_create_template(self, kwargs: dict[str, Any]) -> 'ExprTemplate':
         from pixeltable import exprs
 
-        from .expr_template_function import ExprTemplateFunction
+        from .expr_template_function import ExprTemplate
+
+        assert not self.is_polymorphic
 
         # Resolve each kwarg into a parameter binding
         bindings: dict[str, exprs.Expr] = {}
@@ -127,16 +251,18 @@ class Function(abc.ABC):
         for param in residual_params:
             bindings[param.name] = exprs.Variable(param.name, param.col_type)
 
-        call = exprs.FunctionCall(self, bindings)
+        return_type = self.call_return_type([], bindings)
+        call = exprs.FunctionCall(self, bindings, return_type)
 
         # Construct the (n-k)-ary signature of the new function. We use `call.col_type` for this, rather than
         # `self.signature.return_type`, because the return type of the new function may be specialized via a
         # conditional return type.
         new_signature = Signature(call.col_type, residual_params, self.signature.is_batched)
-        return ExprTemplateFunction(call, new_signature)
+
+        return ExprTemplate(call, new_signature)
 
     @abc.abstractmethod
-    def exec(self, *args: Any, **kwargs: Any) -> Any:
+    def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
         """Execute the function with the given arguments and return the result."""
         pass
 
@@ -164,13 +290,18 @@ class Function(abc.ABC):
         to an instance with from_dict().
         Subclasses can override _as_dict().
         """
+        # We currently only ever serialize a function that has a specific signature (not a polymorphic form).
+        assert not self.is_polymorphic
         classpath = f'{self.__class__.__module__}.{self.__class__.__qualname__}'
         return {'_classpath': classpath, **self._as_dict()}
 
     def _as_dict(self) -> dict:
-        """Default serialization: store the path to self (which includes the module path)"""
+        """Default serialization: store the path to self (which includes the module path) and signature."""
         assert self.self_path is not None
-        return {'path': self.self_path}
+        return {
+            'path': self.self_path,
+            'signature': self.signature.as_dict(),
+        }
 
     @classmethod
     def from_dict(cls, d: dict) -> Function:
@@ -181,15 +312,45 @@ class Function(abc.ABC):
         module_path, class_name = d['_classpath'].rsplit('.', 1)
         class_module = importlib.import_module(module_path)
         func_class = getattr(class_module, class_name)
+        assert isinstance(func_class, type) and issubclass(func_class, Function)
         return func_class._from_dict(d)
 
     @classmethod
     def _from_dict(cls, d: dict) -> Function:
         """Default deserialization: load the symbol indicated by the stored symbol_path"""
         assert 'path' in d and d['path'] is not None
+        assert 'signature' in d and d['signature'] is not None
         instance = resolve_symbol(d['path'])
         assert isinstance(instance, Function)
-        return instance
+
+        # Load the signature from the DB and check that it is still valid (i.e., is still consistent with a signature
+        # in the code).
+        signature = Signature.from_dict(d['signature'])
+        idx = instance.__find_matching_overload(signature)
+        if idx is None:
+            # No match; generate an informative error message.
+            signature_note_str = 'any of its signatures' if instance.is_polymorphic else 'its signature as'
+            instance_signature_str = (
+                f'{len(instance.signatures)} signatures' if instance.is_polymorphic else str(instance.signature)
+            )
+            # TODO: Handle this more gracefully (instead of failing the DB load, allow the DB load to succeed, but
+            #       mark any enclosing FunctionCall as unusable). It's the same issue as dealing with a renamed UDF or
+            #       FunctionCall return type mismatch.
+            raise excs.Error(
+                f'The signature stored in the database for the UDF `{instance.self_path}` no longer matches '
+                f'{signature_note_str} as currently defined in the code.\nThis probably means that the code for '
+                f'`{instance.self_path}` has changed in a backward-incompatible way.\n'
+                f'Signature in database: {signature}\n'
+                f'Signature in code: {instance_signature_str}'
+            )
+        # We found a match; specialize to the appropriate overload resolution (non-polymorphic form) and return that.
+        return instance._resolved_fns[idx]
+
+    def __find_matching_overload(self, sig: Signature) -> Optional[int]:
+        for idx, overload_sig in enumerate(self.signatures):
+            if sig.is_consistent_with(overload_sig):
+                return idx
+        return None
 
     def to_store(self) -> tuple[dict, bytes]:
         """

pixeltable/func/function_registry.py

@@ -13,6 +13,7 @@ import pixeltable.env as env
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
 from pixeltable.metadata import schema
+
 from .function import Function
 
 _logger = logging.getLogger('pixeltable')
@@ -68,7 +69,7 @@ class FunctionRegistry:
             raise excs.Error(f'A UDF with that name already exists: {fqn}')
         self.module_fns[fqn] = fn
         if fn.is_method or fn.is_property:
-            base_type = fn.signature.parameters_by_pos[0].col_type.type_enum
+            base_type = fn.signatures[0].parameters_by_pos[0].col_type.type_enum
             if base_type not in self.type_methods:
                 self.type_methods[base_type] = {}
             if fn.name in self.type_methods[base_type]:

pixeltable/func/query_template_function.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Sequence
 
 import sqlalchemy as sql
 
@@ -33,10 +33,11 @@ class QueryTemplateFunction(Function):
         return QueryTemplateFunction(template_df, sig, path=path, name=name)
 
     def __init__(
-            self, template_df: Optional['pxt.DataFrame'], sig: Optional[Signature], path: Optional[str] = None,
+            self, template_df: Optional['pxt.DataFrame'], sig: Signature, path: Optional[str] = None,
             name: Optional[str] = None,
     ):
-        super().__init__(sig, self_path=path)
+        assert sig is not None
+        super().__init__([sig], self_path=path)
         self.self_name = name
         self.template_df = template_df
 
@@ -48,16 +49,20 @@ class QueryTemplateFunction(Function):
         # convert defaults to Literals
         self.defaults: dict[str, exprs.Literal] = {}  # key: param name, value: default value converted to a Literal
         param_types = self.template_df.parameters()
-        for param in [p for p in self.signature.parameters.values() if p.has_default()]:
+        for param in [p for p in sig.parameters.values() if p.has_default()]:
             assert param.name in param_types
             param_type = param_types[param.name]
             literal_default = exprs.Literal(param.default, col_type=param_type)
             self.defaults[param.name] = literal_default
 
+    def _update_as_overload_resolution(self, signature_idx: int) -> None:
+        pass  # only one signature supported for QueryTemplateFunction
+
     def set_conn(self, conn: Optional[sql.engine.Connection]) -> None:
         self.conn = conn
 
-    def exec(self, *args: Any, **kwargs: Any) -> Any:
+    def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
+        assert not self.is_polymorphic
         bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
         # apply defaults, otherwise we might have Parameters left over
         bound_args.update(
@@ -75,7 +80,7 @@ class QueryTemplateFunction(Function):
         return self.self_name
 
     def _as_dict(self) -> dict:
-        return {'name': self.name, 'signature': self.signature.as_dict(), 'df': self.template_df.as_dict()}
+        return {'name': self.name, 'signature': self.signatures[0].as_dict(), 'df': self.template_df.as_dict()}
 
     @classmethod
     def _from_dict(cls, d: dict) -> Function: