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

pixeltable/func/aggregate_function.py

@@ -12,7 +12,7 @@ from .globals import validate_symbol_path
 from .signature import Parameter, Signature
 
 if TYPE_CHECKING:
-    import pixeltable
+    from pixeltable import exprs
 
 
 class Aggregator(abc.ABC):
@@ -80,6 +80,8 @@ class AggregateFunction(Function):
         """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
@@ -102,14 +104,24 @@ class AggregateFunction(Function):
         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(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)
@@ -157,7 +169,7 @@ class AggregateFunction(Function):
         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'
@@ -194,29 +206,31 @@ class AggregateFunction(Function):
                 )
             group_by_clause = kwargs.pop(self.GROUP_BY_PARAM)
 
+        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(args, kwargs)
+        return_type = resolved_fn.call_return_type(bound_args)
+
         return exprs.FunctionCall(
             resolved_fn,
-            bound_args,
+            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 [],
         )
 
-    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)
+    def validate_call(self, bound_args: dict[str, 'exprs.Expr']) -> None:
         from pixeltable import exprs
 
-        assert not self.is_polymorphic
+        super().validate_call(bound_args)
 
+        # 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)
         for param_name in self.init_param_names[0]:
-            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'
-                )
+            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}>'

pixeltable/func/callable_function.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import inspect
-from typing import Any, Callable, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence
 from uuid import UUID
 
 import cloudpickle  # type: ignore[import-untyped]
@@ -12,6 +12,9 @@ import pixeltable.exceptions as excs
 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.
@@ -192,18 +195,18 @@ class CallableFunction(Function):
         batch_size = md['batch_size']
         return CallableFunction([sig], [py_fn], self_name=name, batch_size=batch_size)
 
-    def validate_call(self, bound_args: dict[str, Any]) -> None:
+    def validate_call(self, bound_args: dict[str, 'exprs.Expr']) -> None:
         from pixeltable import exprs
 
-        assert not self.is_polymorphic
+        super().validate_call(bound_args)
         if self.is_batched:
             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}(): '
-                        f'parameter {param.name} must be a constant value, not a Pixeltable expression'
-                    )
+                # 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}>'

pixeltable/func/expr_template_function.py

@@ -32,17 +32,11 @@ class ExprTemplate:
             assert var.name in self.param_exprs, f"Variable '{var.name}' in expression is not a parameter"
 
         # verify default values
-        self.defaults: dict[str, exprs.Literal] = {}  # key: param name, value: default value converted to a Literal
+        self.defaults: dict[str, exprs.Literal] = {}
         for param in self.signature.parameters.values():
-            if param.default is inspect.Parameter.empty:
+            if param.default is None:
                 continue
-            param_expr = self.param_exprs[param.name]
-            try:
-                literal_default = exprs.Literal(param.default, col_type=param_expr.col_type)
-                self.defaults[param.name] = literal_default
-            except TypeError as e:
-                msg = str(e)
-                raise excs.Error(f"Default value for parameter '{param.name}': {msg[0].lower() + msg[1:]}")
+            self.defaults[param.name] = param.default
 
 
 class ExprTemplateFunction(Function):

pixeltable/func/function.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import importlib
 import inspect
+import typing
 from abc import ABC, abstractmethod
 from copy import copy
 from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, cast
@@ -17,6 +18,8 @@ from .globals import resolve_symbol
 from .signature import Signature
 
 if TYPE_CHECKING:
+    from pixeltable import exprs
+
     from .expr_template_function import ExprTemplate, ExprTemplateFunction
 
 
@@ -152,9 +155,22 @@ class Function(ABC):
     def __call__(self, *args: Any, **kwargs: Any) -> 'pxt.exprs.FunctionCall':
         from pixeltable import exprs
 
+        args = [exprs.Expr.from_object(arg) for arg in args]
+        kwargs = {k: exprs.Expr.from_object(v) for k, v in kwargs.items()}
+
+        for i, expr in enumerate(args):
+            if expr is None:
+                raise excs.Error(f'Argument {i + 1} in call to {self.self_path!r} is not a valid Pixeltable expression')
+        for param_name, expr in kwargs.items():
+            if expr is None:
+                raise excs.Error(
+                    f'Argument {param_name!r} in call to {self.self_path!r} is not a valid Pixeltable expression'
+                )
+
         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)
+        return_type = resolved_fn.call_return_type(bound_args)
+
+        return exprs.FunctionCall(resolved_fn, args, kwargs, return_type)
 
     def _bind_to_matching_signature(self, args: Sequence[Any], kwargs: dict[str, Any]) -> tuple[Self, dict[str, Any]]:
         result: int = -1
@@ -185,49 +201,115 @@ class Function(ABC):
 
         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
+        normalized_args = {k: exprs.Expr.from_object(v) for k, v in bound_args.items()}
+        self._resolved_fns[signature_idx].validate_call(normalized_args)
+        return normalized_args
 
-    def validate_call(self, bound_args: dict[str, Any]) -> None:
+    def validate_call(self, bound_args: dict[str, Optional['exprs.Expr']]) -> None:
         """Override this to do custom validation of the arguments"""
         assert not self.is_polymorphic
+        self.signature.validate_args(bound_args, context=f'in function {self.name!r}')
 
-    def _get_callable_args(self, callable: Callable, kwargs: dict[str, Any]) -> dict[str, Any]:
-        """Return the kwargs to pass to callable, given kwargs passed to this function"""
-        bound_args = self.signature.py_signature.bind(**kwargs).arguments
-        # add defaults to bound_args, if not already present
-        bound_args.update(
-            {
-                name: param.default
-                for name, param in self.signature.parameters.items()
-                if name not in bound_args and param.has_default()
-            }
-        )
-        result: dict[str, Any] = {}
-        sig = inspect.signature(callable)
-        for param in sig.parameters.values():
-            if param.name in bound_args:
-                result[param.name] = bound_args[param.name]
-        return result
-
-    def call_resource_pool(self, kwargs: dict[str, Any]) -> str:
+    def call_resource_pool(self, bound_args: dict[str, 'exprs.Expr']) -> str:
         """Return the resource pool to use for calling this function with the given arguments"""
-        kw_args = self._get_callable_args(self._resource_pool, kwargs)
-        return self._resource_pool(**kw_args)
-
-    def call_return_type(self, args: Sequence[Any], kwargs: dict[str, Any]) -> ts.ColumnType:
+        rp_kwargs = self._assemble_callable_args(self._resource_pool, bound_args)
+        if rp_kwargs is None:
+            # TODO: What to do in this case? An example where this can happen is if model_id is not a constant
+            #   in a call to one of the OpenAI endpoints.
+            raise excs.Error('Could not determine resource pool')
+        return self._resource_pool(**rp_kwargs)
+
+    def call_return_type(self, bound_args: dict[str, 'exprs.Expr']) -> 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(*args, **kwargs).arguments
-        kw_args: dict[str, Any] = {}
-        sig = inspect.signature(self._conditional_return_type)
-        for param in sig.parameters.values():
+            # No conditional return type specified; use the default return type
+            return_type = self.signature.return_type
+        else:
+            crt_kwargs = self._assemble_callable_args(self._conditional_return_type, bound_args)
+            if crt_kwargs is None:
+                # A conditional return type is specified, but one of its arguments is not a constant.
+                # Use the default return type
+                return_type = self.signature.return_type
+            else:
+                # A conditional return type is specified and all its arguments are constants; use the specific
+                # call return type
+                return_type = self._conditional_return_type(**crt_kwargs)
+
+        if return_type.nullable:
+            return return_type
+
+        # 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 = self.signature.parameters[arg_name]
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+            if arg.col_type.nullable and not param.col_type.nullable:
+                return_type = return_type.copy(nullable=True)
+                break
+
+        return return_type
+
+    def _assemble_callable_args(
+        self, callable: Callable, bound_args: dict[str, 'exprs.Expr']
+    ) -> Optional[dict[str, Any]]:
+        """
+        Return the kwargs to pass to callable, given bound_args passed to this function.
+
+        This is used by `conditional_return_type` and `get_resource_pool` to determine call-specific characteristics
+        of this function.
+
+        In both cases, the specified `Callable` takes a subset of the parameters of this Function, which may
+        be typed as either `Expr`s or Python values. Any parameters typed as Python values expect to see constants
+        (Literals); if the corresponding entries in `bound_args` are not constants, then the return value is None.
+        """
+        from pixeltable import exprs
+
+        assert not self.is_polymorphic
+
+        callable_signature = inspect.signature(callable)
+        callable_type_hints = typing.get_type_hints(callable)
+        callable_args: dict[str, Any] = {}
+
+        for param in callable_signature.parameters.values():
+            assert param.name in self.signature.parameters
+
+            arg: exprs.Expr
             if param.name in bound_args:
-                kw_args[param.name] = bound_args[param.name]
-        return self._conditional_return_type(**kw_args)
+                arg = bound_args[param.name]
+            elif self.signature.parameters[param.name].has_default():
+                arg = self.signature.parameters[param.name].default
+            else:
+                # This parameter is missing from bound_args and has no default value, so return None.
+                return None
+            assert isinstance(arg, exprs.Expr)
+
+            expects_expr: Optional[type[exprs.Expr]] = None
+            type_hint = callable_type_hints.get(param.name)
+            if typing.get_origin(type_hint) is not None:
+                type_hint = typing.get_origin(type_hint)  # Remove type subscript if one exists
+            if isinstance(type_hint, type) and issubclass(type_hint, exprs.Expr):
+                # The callable expects an Expr for this parameter. We allow for the case where the
+                # callable requests a specific subtype of Expr.
+                expects_expr = type_hint
+
+            if expects_expr is not None:
+                # The callable is expecting `param.name` to be an Expr. Validate that it's of the appropriate type;
+                # otherwise return None.
+                if isinstance(arg, expects_expr):
+                    callable_args[param.name] = arg
+                else:
+                    return None
+            else:
+                # The callable is expecting `param.name` to be a constant Python value. Unpack a Literal if we find
+                # one; otherwise return None.
+                if isinstance(arg, exprs.Literal):
+                    callable_args[param.name] = arg.val
+                else:
+                    return None
+
+        return callable_args
 
     def conditional_return_type(self, fn: Callable[..., ts.ColumnType]) -> Callable[..., ts.ColumnType]:
         """Instance decorator for specifying a conditional return type for this function"""
@@ -280,18 +362,38 @@ class Function(ABC):
                 raise excs.Error(f'Unknown parameter: {k}')
             param = self.signature.parameters[k]
             expr = exprs.Expr.from_object(v)
+            if not isinstance(expr, exprs.Literal):
+                raise excs.Error(f'Expected a constant value for parameter {k!r} in call to .using()')
             if not param.col_type.is_supertype_of(expr.col_type):
-                raise excs.Error(f'Expected type `{param.col_type}` for parameter `{k}`; got `{expr.col_type}`')
-            bindings[k] = v  # Use the original value, not the Expr (The Expr is only for validation)
+                raise excs.Error(f'Expected type `{param.col_type}` for parameter {k!r}; got `{expr.col_type}`')
+            bindings[k] = expr
 
         residual_params = [p for p in self.signature.parameters.values() if p.name not in bindings]
 
-        # Bind each remaining parameter to a like-named variable
-        for param in residual_params:
-            bindings[param.name] = exprs.Variable(param.name, param.col_type)
-
-        return_type = self.call_return_type([], bindings)
-        call = exprs.FunctionCall(self, bindings, return_type)
+        # Bind each remaining parameter to a like-named variable.
+        # Also construct the call arguments for the template function call. Variables become args when possible;
+        # otherwise, they are passed as kwargs.
+        template_args: list[exprs.Expr] = []
+        template_kwargs: dict[str, exprs.Expr] = {}
+        args_ok = True
+        for name, param in self.signature.parameters.items():
+            if name in bindings:
+                template_kwargs[name] = bindings[name]
+                args_ok = False
+            else:
+                var = exprs.Variable(name, param.col_type)
+                bindings[name] = var
+                if args_ok and param.kind in (
+                    inspect.Parameter.POSITIONAL_ONLY,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                ):
+                    template_args.append(var)
+                else:
+                    template_kwargs[name] = var
+                    args_ok = False
+
+        return_type = self.call_return_type(bindings)
+        call = exprs.FunctionCall(self, template_args, template_kwargs, 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
@@ -370,35 +472,7 @@ class Function(ABC):
         assert 'signature' in d and d['signature'] is not None
         instance = resolve_symbol(d['path'])
         assert isinstance(instance, Function)
-
-        # 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
+        return instance
 
     def to_store(self) -> tuple[dict, bytes]:
         """

pixeltable/func/signature.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
 
 import dataclasses
-import enum
 import inspect
 import json
 import logging
 import typing
-from typing import Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
 
+if TYPE_CHECKING:
+    from pixeltable import exprs
+
 _logger = logging.getLogger('pixeltable')
 
 
@@ -21,25 +23,24 @@ class Parameter:
     kind: inspect._ParameterKind
     # for some reason, this needs to precede is_batched in the dataclass definition,
     # otherwise Python complains that an argument with a default is followed by an argument without a default
-    default: Any = inspect.Parameter.empty  # default value for the parameter
+    default: Optional['exprs.Literal'] = None  # default value for the parameter
     is_batched: bool = False  # True if the parameter is a batched parameter (eg, Batch[dict])
 
     def __post_init__(self) -> None:
-        # make sure that default is json-serializable and of the correct type
-        if self.default is inspect.Parameter.empty or self.default is None:
-            return
-        try:
-            _ = json.dumps(self.default)
-        except TypeError:
-            raise excs.Error(f'Default value for parameter {self.name} is not JSON-serializable: {str(self.default)}')
-        if self.col_type is not None:
-            try:
-                self.col_type.validate_literal(self.default)
-            except TypeError as e:
-                raise excs.Error(f'Default value for parameter {self.name}: {str(e)}')
+        from pixeltable import exprs
+
+        if self.default is not None:
+            if self.col_type is None:
+                raise excs.Error(f'Cannot have a default value for variable parameter {self.name!r}')
+            if not isinstance(self.default, exprs.Literal):
+                raise excs.Error(f'Default value for parameter {self.name!r} is not a constant')
+            if not self.col_type.is_supertype_of(self.default.col_type):
+                raise excs.Error(
+                    f'Default value for parameter {self.name!r} is not of type {self.col_type!r}: {self.default}'
+                )
 
     def has_default(self) -> bool:
-        return self.default is not inspect.Parameter.empty
+        return self.default is not None
 
     def as_dict(self) -> dict[str, Any]:
         return {
@@ -47,17 +48,15 @@ class Parameter:
             'col_type': self.col_type.as_dict() if self.col_type is not None else None,
             'kind': self.kind.name,
             'is_batched': self.is_batched,
-            'has_default': self.has_default(),
-            'default': self.default if self.has_default() else None,
+            'default': None if self.default is None else self.default.as_dict(),
         }
 
     @classmethod
     def from_dict(cls, d: dict[str, Any]) -> Parameter:
-        has_default = d['has_default']
-        if has_default:
-            default = d['default']
-        else:
-            default = inspect.Parameter.empty
+        from pixeltable import exprs
+
+        assert d['default'] is None or isinstance(d['default'], dict), d
+        default = None if d['default'] is None else exprs.Literal.from_dict(d['default'])
         return cls(
             name=d['name'],
             col_type=ts.ColumnType.from_dict(d['col_type']) if d['col_type'] is not None else None,
@@ -67,7 +66,8 @@ class Parameter:
         )
 
     def to_py_param(self) -> inspect.Parameter:
-        return inspect.Parameter(self.name, self.kind, default=self.default)
+        py_default = self.default.val if self.default is not None else inspect.Parameter.empty
+        return inspect.Parameter(self.name, self.kind, default=py_default)
 
 
 T = typing.TypeVar('T')
@@ -147,6 +147,37 @@ class Signature:
 
         return True
 
+    def validate_args(self, bound_args: dict[str, Optional['exprs.Expr']], context: str = '') -> None:
+        if context != '':
+            context = f' ({context})'
+
+        for param_name, arg in bound_args.items():
+            assert param_name in self.parameters
+            param = self.parameters[param_name]
+            is_var_param = param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+            if is_var_param:
+                continue
+            assert param.col_type is not None
+
+            if arg is None:
+                raise excs.Error(f'Parameter {param_name!r}{context}: invalid argument')
+
+            # Check that the argument is consistent with the expected parameter type, with the allowance that
+            # non-nullable parameters can still accept nullable arguments (since in that event, FunctionCall.eval()
+            # detects the Nones and skips evaluation).
+            if not (
+                param.col_type.is_supertype_of(arg.col_type, ignore_nullable=True)
+                # TODO: this is a hack to allow JSON columns to be passed to functions that accept scalar
+                # types. It's necessary to avoid littering notebooks with `apply(str)` calls or equivalent.
+                # (Previously, this wasn't necessary because `is_supertype_of()` was improperly implemented.)
+                # We need to think through the right way to handle this scenario.
+                or (arg.col_type.is_json_type() and param.col_type.is_scalar_type())
+            ):
+                raise excs.Error(
+                    f'Parameter {param_name!r}{context}: argument type {arg.col_type} does not'
+                    f' match parameter type {param.col_type}'
+                )
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Signature):
             return False
@@ -199,6 +230,8 @@ class Signature:
         type_substitutions: Optional[dict] = None,
         is_cls_method: bool = False,
     ) -> list[Parameter]:
+        from pixeltable import exprs
+
         assert (py_fn is None) != (py_params is None)
         if py_fn is not None:
             sig = inspect.signature(py_fn)
@@ -212,7 +245,7 @@ class Signature:
             if is_cls_method and idx == 0:
                 continue  # skip 'self' or 'cls' parameter
             if param.name in cls.SPECIAL_PARAM_NAMES:
-                raise excs.Error(f"'{param.name}' is a reserved parameter name")
+                raise excs.Error(f'{param.name!r} is a reserved parameter name')
             if param.kind == inspect.Parameter.VAR_POSITIONAL or param.kind == inspect.Parameter.VAR_KEYWORD:
                 parameters.append(Parameter(param.name, col_type=None, kind=param.kind))
                 continue
@@ -220,7 +253,7 @@ class Signature:
             # check non-var parameters for name collisions and default value compatibility
             if param_types is not None:
                 if idx >= len(param_types):
-                    raise excs.Error(f'Missing type for parameter {param.name}')
+                    raise excs.Error(f'Missing type for parameter {param.name!r}')
                 param_type = param_types[idx]
                 is_batched = False
             else:
@@ -231,12 +264,14 @@ class Signature:
                     py_type = param.annotation
                 param_type, is_batched = cls._infer_type(py_type)
                 if param_type is None:
-                    raise excs.Error(f'Cannot infer pixeltable type for parameter {param.name}')
+                    raise excs.Error(f'Cannot infer pixeltable type for parameter {param.name!r}')
+
+            default = None if param.default is inspect.Parameter.empty else exprs.Expr.from_object(param.default)
+            if not (default is None or isinstance(default, exprs.Literal)):
+                raise excs.Error(f'Default value for parameter {param.name!r} must be a constant')
 
             parameters.append(
-                Parameter(
-                    param.name, col_type=param_type, kind=param.kind, is_batched=is_batched, default=param.default
-                )
+                Parameter(param.name, col_type=param_type, kind=param.kind, is_batched=is_batched, default=default)
             )
 
         return parameters

pixeltable/func/udf.py

@@ -283,7 +283,7 @@ def from_table(
                 result_dict[name] = var
                 # Since this is a data column, it becomes a UDF parameter.
                 # If the column is nullable, then the parameter will have a default value of None.
-                default_value = None if col.col_type.nullable else inspect.Parameter.empty
+                default_value = exprs.Literal(None) if col.col_type.nullable else None
                 param = Parameter(name, col.col_type, inspect._ParameterKind.POSITIONAL_OR_KEYWORD, default_value)
                 params.append(param)
 

pixeltable/functions/__init__.py

@@ -3,6 +3,7 @@ from pixeltable.utils.code import local_public_names
 from . import (
     anthropic,
     audio,
+    deepseek,
     fireworks,
     gemini,
     huggingface,