pixeltable 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

pixeltable/exprs/row_builder.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple, Set, Iterable
-from dataclasses import dataclass
-import time
+
 import sys
+import time
+from dataclasses import dataclass
+from typing import Optional, List, Any, Dict, Tuple, Set
+
+import sqlalchemy as sql
 
+import pixeltable.catalog as catalog
+import pixeltable.exceptions as excs
+import pixeltable.func as func
+import pixeltable.utils as utils
+from .data_row import DataRow
 from .expr import Expr
 from .expr_set import ExprSet
-from .data_row import DataRow
-import pixeltable.utils as utils
-import pixeltable.func as func
-import pixeltable.exceptions as excs
-import pixeltable.catalog as catalog
 
 
 class ExecProfile:
@@ -74,10 +77,10 @@ class RowBuilder:
         # - explicitly requested output_exprs
         # - values for computed columns
         resolve_cols = set(columns)
-        self.output_exprs = [
+        self.output_exprs = ExprSet([
             self._record_unique_expr(e.copy().resolve_computed_cols(resolve_cols=resolve_cols), recursive=True)
             for e in output_exprs
-        ]
+        ])
 
         # record columns for create_table_row()
         from .column_ref import ColumnRef
@@ -88,16 +91,15 @@ class RowBuilder:
                 # create a copy here so we don't reuse execution state and resolve references to computed columns
                 expr = col.value_expr.copy().resolve_computed_cols(resolve_cols=resolve_cols)
                 expr = self._record_unique_expr(expr, recursive=True)
-                self.add_table_column(col, expr.slot_idx)
-                self.output_exprs.append(expr)
             else:
                 # record a ColumnRef so that references to this column resolve to the same slot idx
-                ref = ColumnRef(col)
-                ref = self._record_unique_expr(ref, recursive=False)
-                self.add_table_column(col, ref.slot_idx)
+                expr = ColumnRef(col)
+                expr = self._record_unique_expr(expr, recursive=False)
+            self.add_table_column(col, expr.slot_idx)
+            self.output_exprs.append(expr)
 
         # default eval ctx: all output exprs
-        self.default_eval_ctx = self.create_eval_ctx(self.output_exprs, exclude=unique_input_exprs)
+        self.default_eval_ctx = self.create_eval_ctx(list(self.output_exprs), exclude=unique_input_exprs)
 
         # references to unstored iterator columns:
         # - those ColumnRefs need to instantiate iterators
@@ -107,9 +109,11 @@ class RowBuilder:
         # - the separate eval ctx allows the ColumnRef to materialize the iterator args only when the underlying
         #   iterated object changes
         col_refs = [e for e in self.unique_exprs if isinstance(e, ColumnRef)]
+
         def refs_unstored_iter_col(col_ref: ColumnRef) -> bool:
             tbl = col_ref.col.tbl
             return tbl.is_component_view() and tbl.is_iterator_column(col_ref.col) and not col_ref.col.is_stored
+
         unstored_iter_col_refs = [col_ref for col_ref in col_refs if refs_unstored_iter_col(col_ref)]
         component_views = [col_ref.col.tbl for col_ref in unstored_iter_col_refs]
         unstored_iter_args = {view.id: view.iterator_args.copy() for view in component_views}
@@ -154,13 +158,19 @@ class RowBuilder:
         """Return ColumnSlotIdx for output columns"""
         return self.table_columns
 
+    def set_conn(self, conn: sql.engine.Connection) -> None:
+        from .function_call import FunctionCall
+        for expr in self.unique_exprs:
+            if isinstance(expr, FunctionCall) and isinstance(expr.fn, func.QueryTemplateFunction):
+                expr.fn.set_conn(conn)
+
     @property
     def num_materialized(self) -> int:
         return self.next_slot_idx
 
-    def get_output_exprs(self) -> List[Expr]:
+    def get_output_exprs(self) -> list[Expr]:
         """Returns exprs that were requested in the c'tor and require evaluation"""
-        return self.output_exprs
+        return list(self.output_exprs)
 
     def _next_slot_idx(self) -> int:
         result = self.next_slot_idx
@@ -252,7 +262,7 @@ class RowBuilder:
         result_ids.sort()
         return [self.unique_exprs[id] for id in result_ids]
 
-    def create_eval_ctx(self, targets: List[Expr], exclude: Optional[List[Expr]] = None) -> EvalCtx:
+    def create_eval_ctx(self, targets: list[Expr], exclude: Optional[list[Expr]] = None) -> EvalCtx:
         """Return EvalCtx for targets"""
         if exclude is None:
             exclude = []
@@ -326,4 +336,3 @@ class RowBuilder:
                 table_row[col.errormsg_store_name()] = None
 
         return table_row, num_excs
-

pixeltable/exprs/similarity_expr.py

@@ -18,7 +18,6 @@ class SimilarityExpr(Expr):
         super().__init__(ts.FloatType())
         self.components = [col_ref, item]
         self.id = self._create_id()
-        assert isinstance(item, Literal)
         assert item.col_type.is_string_type() or item.col_type.is_image_type()
 
         # determine index to use
@@ -47,12 +46,14 @@ class SimilarityExpr(Expr):
         return f'{self.components[0]}.similarity({self.components[1]})'
 
     def sql_expr(self) -> Optional[sql.ClauseElement]:
-        assert isinstance(self.components[1], Literal)
+        if not isinstance(self.components[1], Literal):
+             raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
         return self.idx_info.idx.similarity_clause(self.idx_info.val_col, item)
 
     def as_order_by_clause(self, is_asc: bool) -> Optional[sql.ClauseElement]:
-        assert isinstance(self.components[1], Literal)
+        if not isinstance(self.components[1], Literal):
+            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
         return self.idx_info.idx.order_by_clause(self.idx_info.val_col, item, is_asc)
 

pixeltable/ext/functions/yolox.py

@@ -14,7 +14,7 @@ from yolox.utils import postprocess
 import pixeltable as pxt
 from pixeltable import env
 from pixeltable.func import Batch
-from pixeltable.functions.util import resolve_torch_device
+from pixeltable.functions.util import normalize_image_mode
 
 _logger = logging.getLogger('pixeltable')
 
@@ -74,6 +74,7 @@ def yolo_to_coco(detections: dict) -> list:
 
 def _images_to_tensors(images: Iterable[PIL.Image.Image], exp: Exp) -> Iterator[torch.Tensor]:
     for image in images:
+        image = normalize_image_mode(image)
         image_transform, _ = _val_transform(np.array(image), None, exp.test_size)
         yield torch.from_numpy(image_transform)
 

pixeltable/func/__init__.py

@@ -3,5 +3,6 @@ from .callable_function import CallableFunction
 from .expr_template_function import ExprTemplateFunction
 from .function import Function
 from .function_registry import FunctionRegistry
+from .query_template_function import QueryTemplateFunction
 from .signature import Signature, Parameter, Batch
 from .udf import udf, make_function, expr_udf

pixeltable/func/aggregate_function.py

@@ -43,27 +43,29 @@ class AggregateFunction(Function):
 
         # our signature is the signature of 'update', but without self,
         # plus the parameters of 'init' as keyword-only parameters
-        update_params = list(inspect.signature(self.agg_cls.update).parameters.values())[1:]  # leave out self
-        assert len(update_params) == len(update_types)
+        py_update_params = list(inspect.signature(self.agg_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)
+            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:]
+        assert len(py_init_params) == len(init_types)
         init_params = [
-            inspect.Parameter(p.name, inspect.Parameter.KEYWORD_ONLY, default=p.default)
-            # starting at 1: leave out self
-            for p in itertools.islice(inspect.signature(self.agg_cls.__init__).parameters.values(), 1, None)
+            Parameter(p.name, col_type=init_types[i], kind=inspect.Parameter.KEYWORD_ONLY, default=p.default)
+            for i, p in enumerate(py_init_params)
         ]
-        assert len(init_params) == len(init_types)
         duplicate_params = set(p.name for p in init_params) & set(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)}'
             )
-        py_params = update_params + init_params  # init_params are keyword-only and come last
-        py_signature = inspect.Signature(py_params)
+        params = update_params + init_params  # init_params are keyword-only and come last
 
-        params = [Parameter(p.name, update_types[i], p.kind, is_batched=False) for i, p in enumerate(update_params)]
-        params.extend([Parameter(p.name, init_types[i], p.kind, is_batched=False) for i, p in enumerate(init_params)])
         signature = Signature(value_type, params)
-        super().__init__(signature, py_signature=py_signature, self_path=self_path)
+        super().__init__(signature, self_path=self_path)
         self.init_param_names = [p.name for p in init_params]
 
         # make sure the signature doesn't contain reserved parameter names;
@@ -115,7 +117,7 @@ class AggregateFunction(Function):
                     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.py_signature.bind(*args, **kwargs)
+        bound_args = self.signature.py_signature.bind(*args, **kwargs)
         self.validate_call(bound_args.arguments)
         return exprs.FunctionCall(
             self, bound_args.arguments,

pixeltable/func/callable_function.py

@@ -25,8 +25,7 @@ class CallableFunction(Function):
         self.py_fn = py_fn
         self.self_name = self_name
         self.batch_size = batch_size
-        py_signature = inspect.signature(self.py_fn)
-        super().__init__(signature, py_signature, self_path=self_path)
+        super().__init__(signature, self_path=self_path)
 
     @property
     def is_batched(self) -> bool:
@@ -91,16 +90,19 @@ class CallableFunction(Function):
         return super()._from_dict(d)
 
     def to_store(self) -> tuple[dict, bytes]:
-        md = self.signature.as_dict()
-        if self.batch_size is not None:
-            md['batch_size'] = self.batch_size
+        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:
         py_fn = cloudpickle.loads(binary_obj)
         assert isinstance(py_fn, Callable)
-        return CallableFunction(Signature.from_dict(md), py_fn, self_name=name, batch_size=md.get('batch_size'))
+        sig = Signature.from_dict(md['signature'])
+        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:
         import pixeltable.exprs as exprs

pixeltable/func/expr_template_function.py

@@ -11,7 +11,7 @@ class ExprTemplateFunction(Function):
     """A parameterized expression from which an executable Expr is created with a function call."""
 
     def __init__(
-            self, expr: 'pixeltable.exprs.Expr', py_signature: inspect.Signature, self_path: Optional[str] = None,
+            self, expr: 'pixeltable.exprs.Expr', signature: Signature, self_path: Optional[str] = None,
             name: Optional[str] = None):
         import pixeltable.exprs as exprs
         self.expr = expr
@@ -23,28 +23,21 @@ class ExprTemplateFunction(Function):
 
         # verify default values
         self.defaults: Dict[str, exprs.Literal] = {}  # key: param name, value: default value converted to a Literal
-        for py_param in py_signature.parameters.values():
-            if py_param.default is inspect.Parameter.empty:
+        for param in signature.parameters.values():
+            if param.default is inspect.Parameter.empty:
                 continue
-            param_expr = self.param_exprs_by_name[py_param.name]
+            param_expr = self.param_exprs_by_name[param.name]
             try:
-                literal_default = exprs.Literal(py_param.default, col_type=param_expr.col_type)
-                self.defaults[py_param.name] = literal_default
+                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 '{py_param.name}': {msg[0].lower() + msg[1:]}")
-        # construct signature
-        assert len(self.param_exprs) == len(py_signature.parameters)
-        fn_params = [
-            Parameter(p.name, self.param_exprs_by_name[p.name].col_type, p.kind)
-            for p in py_signature.parameters.values()
-        ]
-        signature = Signature(return_type=expr.col_type, parameters=fn_params)
+                raise excs.Error(f"Default value for parameter '{param.name}': {msg[0].lower() + msg[1:]}")
 
-        super().__init__(signature, py_signature=py_signature, self_path=self_path)
+        super().__init__(signature, self_path=self_path)
 
     def instantiate(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.Expr':
-        bound_args = self.py_signature.bind(*args, **kwargs).arguments
+        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})
@@ -88,14 +81,15 @@ class ExprTemplateFunction(Function):
         if self.self_path is not None:
             return super()._as_dict()
         return {
-            'name': self.name,
             'expr': self.expr.as_dict(),
-            **super()._as_dict()
+            'signature': self.signature.as_dict(),
+            'name': self.name,
         }
 
     @classmethod
     def _from_dict(cls, d: Dict) -> Function:
         if 'expr' not in 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']), name=d['name'])
+        return cls(exprs.Expr.from_dict(d['expr']), Signature.from_dict(d['signature']), name=d['name'])

pixeltable/func/function.py

@@ -19,11 +19,8 @@ class Function(abc.ABC):
     via the member self_path.
     """
 
-    def __init__(
-            self, signature: Signature, py_signature: inspect.Signature, self_path: Optional[str] = None
-    ):
+    def __init__(self, signature: Signature, self_path: Optional[str] = None):
         self.signature = signature
-        self.py_signature = py_signature
         self.self_path = self_path  # fully-qualified path to self
         self._conditional_return_type: Optional[Callable[..., ts.ColumnType]] = None
 
@@ -46,7 +43,7 @@ class Function(abc.ABC):
 
     def __call__(self, *args: Any, **kwargs: Any) -> 'pixeltable.exprs.Expr':
         from pixeltable import exprs
-        bound_args = self.py_signature.bind(*args, **kwargs)
+        bound_args = self.signature.py_signature.bind(*args, **kwargs)
         self.validate_call(bound_args.arguments)
         return exprs.FunctionCall(self, bound_args.arguments)
 
@@ -58,7 +55,7 @@ class Function(abc.ABC):
         """Return the type of the value returned by calling this function with the given arguments"""
         if self._conditional_return_type is None:
             return self.signature.return_type
-        bound_args = self.py_signature.bind(**kwargs)
+        bound_args = self.signature.py_signature.bind(**kwargs)
         kw_args: dict[str, Any] = {}
         sig = inspect.signature(self._conditional_return_type)
         for param in sig.parameters.values():

pixeltable/func/query_template_function.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+import inspect
+from typing import Dict, Optional, Any, Callable
+
+import sqlalchemy as sql
+
+import pixeltable
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
+from .function import Function
+from .signature import Signature, Parameter
+
+
+class QueryTemplateFunction(Function):
+    """A parameterized query/DataFrame from which an executable DataFrame is created with a function call."""
+
+    @classmethod
+    def create(
+            cls, template_callable: Callable, param_types: Optional[list[ts.ColumnType]], path: str, name: str
+    ) -> QueryTemplateFunction:
+        # we need to construct a template df and a signature
+        py_sig = inspect.signature(template_callable)
+        py_params = list(py_sig.parameters.values())
+        params = Signature.create_parameters(py_params=py_params, param_types=param_types)
+        # invoke template_callable with parameter expressions to construct a DataFrame with parameters
+        import pixeltable.exprs as exprs
+        var_exprs = [exprs.Variable(param.name, param.col_type) for param in params]
+        template_df = template_callable(*var_exprs)
+        from pixeltable import DataFrame
+        assert isinstance(template_df, DataFrame)
+        # we take params and return json
+        sig = Signature(return_type=ts.JsonType(), parameters=params)
+        return QueryTemplateFunction(template_df, sig, path=path, name=name)
+
+    def __init__(
+            self, template_df: Optional['pixeltable.DataFrame'], sig: Optional[Signature], path: Optional[str] = None,
+            name: Optional[str] = None,
+    ):
+        super().__init__(sig, self_path=path)
+        self.self_name = name
+        self.template_df = template_df
+
+        # if we're running as part of an ongoing update operation, we need to use the same connection, otherwise
+        # we end up with a deadlock
+        # TODO: figure out a more general way to make execution state available
+        self.conn: Optional[sql.engine.Connection] = None
+
+        # convert defaults to Literals
+        import pixeltable.exprs as exprs
+        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()]:
+            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 set_conn(self, conn: Optional[sql.engine.Connection]) -> None:
+        self.conn = conn
+
+    def exec(self, *args: Any, **kwargs: Any) -> Any:
+        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})
+        bound_df = self.template_df.bind(bound_args)
+        result = bound_df._collect(self.conn)
+        return list(result)
+
+    @property
+    def display_name(self) -> str:
+        return self.self_name
+
+    @property
+    def name(self) -> str:
+        return self.self_name
+
+    def _as_dict(self) -> Dict:
+        return {'name': self.name, 'signature': self.signature.as_dict(), 'df': self.template_df.as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: Dict) -> Function:
+        from pixeltable.dataframe import DataFrame
+        return cls(DataFrame.from_dict(d['df']), Signature.from_dict(d['signature']), name=d['name'])

pixeltable/func/signature.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import dataclasses
 import enum
 import inspect
@@ -18,8 +19,56 @@ class Parameter:
     name: str
     col_type: Optional[ts.ColumnType]  # None for variable parameters
     kind: enum.Enum  # inspect.Parameter.kind; inspect._ParameterKind is private
+    # 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
     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)}')
+
+    def has_default(self) -> bool:
+        return self.default is not inspect.Parameter.empty
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            'name': self.name,
+            '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,
+        }
+
+    @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
+        return cls(
+            name=d['name'],
+            col_type=ts.ColumnType.from_dict(d['col_type']) if d['col_type'] is not None else None,
+            kind=getattr(inspect.Parameter, d['kind']),
+            is_batched=d['is_batched'],
+            default=default
+        )
+
+    def to_py_param(self) -> inspect.Parameter:
+        return inspect.Parameter(self.name, self.kind, default=self.default)
+
 
 T = typing.TypeVar('T')
 Batch = typing.Annotated[list[T], 'pxt-batch']
@@ -42,6 +91,7 @@ class Signature:
         self.parameters_by_pos = parameters.copy()
         self.constant_parameters = [p for p in parameters if not p.is_batched]
         self.batched_parameters = [p for p in parameters if p.is_batched]
+        self.py_signature = inspect.Signature([p.to_py_param() for p in self.parameters_by_pos])
 
     def get_return_type(self) -> ts.ColumnType:
         assert isinstance(self.return_type, ts.ColumnType)
@@ -50,17 +100,15 @@ class Signature:
     def as_dict(self) -> Dict[str, Any]:
         result = {
             'return_type': self.get_return_type().as_dict(),
-            'parameters': [
-                [p.name, p.col_type.as_dict() if p.col_type is not None else None, p.kind, p.is_batched]
-                for p in self.parameters.values()
-            ]
+            'parameters': [p.as_dict() for p in self.parameters.values()],
+            'is_batched': self.is_batched,
         }
         return result
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> Signature:
-        parameters = [Parameter(p[0], ts.ColumnType.from_dict(p[1]), p[2], p[3]) for p in d['parameters']]
-        return cls(ts.ColumnType.from_dict(d['return_type']), parameters)
+        parameters = [Parameter.from_dict(param_dict) for param_dict in d['parameters']]
+        return cls(ts.ColumnType.from_dict(d['return_type']), parameters, d['is_batched'])
 
     def __eq__(self, other: Signature) -> bool:
         if self.get_return_type() != other.get_return_type():
@@ -105,16 +153,20 @@ class Signature:
 
     @classmethod
     def create_parameters(
-            cls, c: Callable, param_types: Optional[List[ts.ColumnType]] = None) -> List[Parameter]:
-        sig = inspect.signature(c)
-        py_parameters = list(sig.parameters.values())
+            cls, py_fn: Optional[Callable] = None, py_params: Optional[list[inspect.Parameter]] = None,
+            param_types: Optional[List[ts.ColumnType]] = None
+    ) -> List[Parameter]:
+        assert (py_fn is None) != (py_params is None)
+        if py_fn is not None:
+            sig = inspect.signature(py_fn)
+            py_params = list(sig.parameters.values())
         parameters: List[Parameter] = []
 
-        for idx, param in enumerate(py_parameters):
+        for idx, param in enumerate(py_params):
             if param.name in cls.SPECIAL_PARAM_NAMES:
                 raise excs.Error(f"'{param.name}' is a reserved parameter name")
             if param.kind == inspect.Parameter.VAR_POSITIONAL or param.kind == inspect.Parameter.VAR_KEYWORD:
-                parameters.append(Parameter(param.name, None, param.kind, False))
+                parameters.append(Parameter(param.name, col_type=None, kind=param.kind))
                 continue
 
             # check non-var parameters for name collisions and default value compatibility
@@ -128,21 +180,14 @@ class Signature:
                 if param_type is None:
                     raise excs.Error(f'Cannot infer pixeltable type for parameter {param.name}')
 
-            # check default value compatibility
-            default_val = sig.parameters[param.name].default
-            if default_val != inspect.Parameter.empty and default_val is not None:
-                try:
-                    _ = param_type.create_literal(default_val)
-                except TypeError as e:
-                    raise excs.Error(f'Default value for parameter {param.name}: {str(e)}')
-
-            parameters.append(Parameter(param.name, param_type, param.kind, is_batched))
+            parameters.append(Parameter(
+                param.name, col_type=param_type, kind=param.kind, is_batched=is_batched, default=param.default))
 
         return parameters
 
     @classmethod
     def create(
-            cls, c: Callable,
+            cls, py_fn: Callable,
             param_types: Optional[List[ts.ColumnType]] = None,
             return_type: Optional[Union[ts.ColumnType, Callable]] = None
     ) -> Signature:
@@ -150,8 +195,8 @@ class Signature:
         Infer the parameter and return types, if none are specified.
         Raises an exception if the types cannot be inferred.
         """
-        parameters = cls.create_parameters(c, param_types)
-        sig = inspect.signature(c)
+        parameters = cls.create_parameters(py_fn=py_fn, param_types=param_types)
+        sig = inspect.signature(py_fn)
         if return_type is None:
             return_type, return_is_batched = cls._infer_type(sig.return_annotation)
             if return_type is None:

pixeltable/func/udf.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import inspect
 from typing import List, Callable, Optional, overload, Any
 
 import pixeltable as pxt
@@ -56,8 +55,12 @@ def udf(*args, **kwargs):
         return_type = kwargs.pop('return_type', None)
         param_types = kwargs.pop('param_types', None)
         batch_size = kwargs.pop('batch_size', None)
-        substitute_fn = kwargs.pop('py_fn', None)
+        substitute_fn = kwargs.pop('substitute_fn', None)
         force_stored = kwargs.pop('_force_stored', False)
+        if len(kwargs) > 0:
+            raise excs.Error(f'Invalid @udf decorator kwargs: {", ".join(kwargs.keys())}')
+        if len(args) > 0:
+            raise excs.Error('Unexpected @udf decorator arguments.')
 
         def decorator(decorated_fn: Callable):
             return make_function(
@@ -134,7 +137,7 @@ def expr_udf(py_fn: Callable) -> ExprTemplateFunction: ...
 def expr_udf(*, param_types: Optional[List[ts.ColumnType]] = None) -> Callable[[Callable], ExprTemplateFunction]: ...
 
 def expr_udf(*args: Any, **kwargs: Any) -> Any:
-    def decorator(py_fn: Callable, param_types: Optional[List[ts.ColumnType]]) -> ExprTemplateFunction:
+    def make_expr_template(py_fn: Callable, param_types: Optional[List[ts.ColumnType]]) -> ExprTemplateFunction:
         if py_fn.__module__ != '__main__' and py_fn.__name__.isidentifier():
             # this is a named function in a module
             function_path = f'{py_fn.__module__}.{py_fn.__qualname__}'
@@ -144,21 +147,21 @@ def expr_udf(*args: Any, **kwargs: Any) -> Any:
         # TODO: verify that the inferred return type matches that of the template
         # TODO: verify that the signature doesn't contain batched parameters
 
-        # construct Parameters from the function signature
-        params = Signature.create_parameters(py_fn, param_types=param_types)
+        # construct Signature from the function signature
+        sig = Signature.create(py_fn=py_fn, param_types=param_types, return_type=ts.InvalidType())
         import pixeltable.exprs as exprs
-        var_exprs = [exprs.Variable(param.name, param.col_type) for param in params]
+        var_exprs = [exprs.Variable(param.name, param.col_type) for param in sig.parameters.values()]
         # call the function with the parameter expressions to construct an Expr with parameters
         template = py_fn(*var_exprs)
         assert isinstance(template, exprs.Expr)
-        py_sig = inspect.signature(py_fn)
+        sig.return_type = template.col_type
         if function_path is not None:
             validate_symbol_path(function_path)
-        return ExprTemplateFunction(template, py_signature=py_sig, self_path=function_path, name=py_fn.__name__)
+        return ExprTemplateFunction(template, sig, self_path=function_path, name=py_fn.__name__)
 
     if len(args) == 1:
         assert len(kwargs) == 0 and callable(args[0])
-        return decorator(args[0], None)
+        return make_expr_template(args[0], None)
     else:
         assert len(args) == 0 and len(kwargs) == 1 and 'param_types' in kwargs
-        return lambda py_fn: decorator(py_fn, kwargs['param_types'])
+        return lambda py_fn: make_expr_template(py_fn, kwargs['param_types'])