pixeltable 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

pixeltable/exprs/image_member_access.py

@@ -1,19 +1,17 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple, Union
+
+from typing import Optional, List, Any, Dict, Tuple
 
 import PIL
 import sqlalchemy as sql
 
+import pixeltable.exceptions as excs
+import pixeltable.func as func
+import pixeltable.type_system as ts
+from .data_row import DataRow
 from .expr import Expr
-from .column_ref import ColumnRef
 from .function_call import FunctionCall
-from .image_similarity_predicate import ImageSimilarityPredicate
-from .data_row import DataRow
 from .row_builder import RowBuilder
-import pixeltable.catalog as catalog
-import pixeltable.func as func
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
 
 
 # TODO: this doesn't dig up all attrs for actual jpeg images
@@ -43,9 +41,7 @@ class ImageMemberAccess(Expr):
     attr_info = _create_pil_attr_info()
 
     def __init__(self, member_name: str, caller: Expr):
-        if member_name == 'nearest':
-            super().__init__(ts.InvalidType())  # requires FunctionCall to return value
-        elif member_name in self.attr_info:
+        if member_name in self.attr_info:
             super().__init__(self.attr_info[member_name])
         else:
             candidates = func.FunctionRegistry.get().get_type_methods(member_name, ts.ColumnType.Type.IMAGE)
@@ -78,22 +74,8 @@ class ImageMemberAccess(Expr):
         assert len(components) == 1
         return cls(d['member_name'], components[0])
 
-    def __call__(self, *args, **kwargs) -> Union[FunctionCall, ImageSimilarityPredicate]:
-        caller = self._caller
-        call_signature = f'({",".join([type(arg).__name__ for arg in args])})'
-        if self.member_name == 'nearest':
-            # - caller must be ColumnRef
-            # - signature is (Union[PIL.Image.Image, str])
-            if not isinstance(caller, ColumnRef):
-                raise excs.Error(f'nearest(): caller must be an image column')
-            if len(args) != 1 or (not isinstance(args[0], PIL.Image.Image) and not isinstance(args[0], str)):
-                raise excs.Error(f'nearest(): requires a PIL.Image.Image or str, got {call_signature} instead')
-            return ImageSimilarityPredicate(
-                caller,
-                img=args[0] if isinstance(args[0], PIL.Image.Image) else None,
-                text=args[0] if isinstance(args[0], str) else None)
-
-        result = self.img_method(*[caller, *args], **kwargs)
+    def __call__(self, *args, **kwargs) -> FunctionCall:
+        result = self.img_method(*[self._caller, *args], **kwargs)
         result.is_method_call = True
         return result
 
@@ -112,4 +94,3 @@ class ImageMemberAccess(Expr):
             data_row[self.slot_idx] = getattr(caller_val, self.member_name)
         except AttributeError:
             data_row[self.slot_idx] = None
-

pixeltable/exprs/in_predicate.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import Optional, List, Any, Dict, Tuple, Iterable
+
+import sqlalchemy as sql
+
+import pixeltable.exceptions as excs
+from .data_row import DataRow
+from .expr import Expr
+from .predicate import Predicate
+from .row_builder import RowBuilder
+
+
+class InPredicate(Predicate):
+    """Predicate corresponding to the SQL IN operator."""
+
+    def __init__(self, lhs: Expr, value_set_literal: Optional[Iterable] = None, value_set_expr: Optional[Expr] = None):
+        assert (value_set_literal is None) != (value_set_expr is None)
+        if not lhs.col_type.is_scalar_type():
+            raise excs.Error(f'isin(): only supported for scalar types, not {lhs.col_type}')
+        super().__init__()
+
+        self.value_list: Optional[list] = None  # only contains values of the correct type
+        if value_set_expr is not None:
+            if not value_set_expr.col_type.is_json_type():
+                raise excs.Error(
+                    f'isin(): argument must have a JSON type, but {value_set_expr} has type {value_set_expr.col_type}')
+            self.components = [lhs.copy(), value_set_expr.copy()]
+        else:
+            assert value_set_literal is not None
+            self.components = [lhs.copy()]
+            self.value_list = self._normalize_value_set(value_set_literal)
+
+        self.id = self._create_id()
+
+    @property
+    def _lhs(self) -> Expr:
+        return self.components[0]
+
+    @property
+    def _value_set_expr(self) -> Expr:
+        assert len(self.components) == 2
+        return self.components[1]
+
+    def _normalize_value_set(self, value_set: Any, filter_type_mismatches: bool = True) -> Iterable:
+        if not isinstance(value_set, Iterable):
+            raise excs.Error(f'isin(): argument must be an Iterable (eg, list, dict, ...), not {value_set!r}')
+        value_list = list(value_set)
+        if not filter_type_mismatches:
+            return value_list
+
+        # ignore elements of the wrong type
+        result = []
+        for val in value_list:
+            try:
+                self._lhs.col_type.validate_literal(val)
+                result.append(val)
+            except TypeError:
+                pass
+        return result
+
+    def __str__(self) -> str:
+        if self.value_list is not None:
+            return f'{self.components[0]}.isin({self.value_list})'
+        return f'{self.components[0]}.isin({self.components[1]})'
+
+    def _equals(self, other: InPredicate) -> bool:
+        return self.value_list == other.value_list
+
+    def _id_attrs(self) -> List[Tuple[str, Any]]:
+        return super()._id_attrs() + [('value_list', self.value_list)]
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        lhs_sql_exprs = self.components[0].sql_expr()
+        if lhs_sql_exprs is None or self.value_list is None:
+            return None
+        return lhs_sql_exprs.in_(self.value_list)
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        lhs_val = data_row[self._lhs.slot_idx]
+        if self.value_list is not None:
+            data_row[self.slot_idx] = lhs_val in self.value_list
+        else:
+            value_set = data_row[self._value_set_expr.slot_idx]
+            value_list = self._normalize_value_set(value_set, filter_type_mismatches=False)
+            data_row[self.slot_idx] = lhs_val in value_list
+
+    def _as_dict(self) -> Dict:
+        return {'value_list': self.value_list, **super()._as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+        assert 'value_list' in d
+        assert len(components) <= 2
+        return cls(components[0], d['value_list'], components[1] if len(components) == 2 else None)
+

pixeltable/exprs/inline_array.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple
+
 import copy
+from typing import Optional, List, Any, Dict, Tuple
 
-import sqlalchemy as sql
 import numpy as np
+import sqlalchemy as sql
 
-from .expr import Expr
+import pixeltable.type_system as ts
 from .data_row import DataRow
+from .expr import Expr
 from .inline_dict import InlineDict
 from .row_builder import RowBuilder
-import pixeltable.catalog as catalog
-import pixeltable.type_system as ts
 
 
 class InlineArray(Expr):
@@ -27,8 +27,8 @@ class InlineArray(Expr):
 
         # elements contains
         # - for Expr elements: (index into components, None)
-        # - for non-Expr elements: (-1, value)
-        self.elements: List[Tuple[int, Any]] = []
+        # - for non-Expr elements: (None, value)
+        self.elements: List[Tuple[Optional[int], Any]] = []
         for el in elements:
             el = copy.deepcopy(el)
             if isinstance(el, list):
@@ -41,11 +41,11 @@ class InlineArray(Expr):
                 self.elements.append((len(self.components), None))
                 self.components.append(el)
             else:
-                self.elements.append((-1, el))
+                self.elements.append((None, el))
 
         inferred_element_type = ts.InvalidType()
         for idx, val in self.elements:
-            if idx >= 0:
+            if idx is not None:
                 inferred_element_type = ts.ColumnType.supertype(inferred_element_type, self.components[idx].col_type)
             else:
                 inferred_element_type = ts.ColumnType.supertype(inferred_element_type, ts.ColumnType.infer_literal_type(val))
@@ -83,7 +83,7 @@ class InlineArray(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         result = [None] * len(self.elements)
         for i, (child_idx, val) in enumerate(self.elements):
-            if child_idx >= 0:
+            if child_idx is not None:
                 result[i] = data_row[self.components[child_idx].slot_idx]
             else:
                 result[i] = copy.deepcopy(val)
@@ -100,7 +100,9 @@ class InlineArray(Expr):
         assert 'elements' in d
         arg: List[Any] = []
         for idx, val in d['elements']:
-            if idx >= 0:
+            # TODO Normalize idx -1 to None via schema migrations.
+            # Long-term we should not be allowing idx == -1.
+            if idx is not None and idx >= 0:  # Older schemas might have -1 instead of None
                 arg.append(components[idx])
             else:
                 arg.append(val)

pixeltable/exprs/inline_dict.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple
+
 import copy
+from typing import Optional, List, Any, Dict, Tuple
 
 import sqlalchemy as sql
 
-from .expr import Expr
-from .data_row import DataRow
-from .row_builder import RowBuilder
 import pixeltable.exceptions as excs
-import pixeltable.catalog as catalog
 import pixeltable.type_system as ts
+from .data_row import DataRow
+from .expr import Expr
+from .row_builder import RowBuilder
 
 
 class InlineDict(Expr):
@@ -21,8 +21,8 @@ class InlineDict(Expr):
         super().__init__(ts.JsonType())  # we need to call this in order to populate self.components
         # dict_items contains
         # - for Expr fields: (key, index into components, None)
-        # - for non-Expr fields: (key, -1, value)
-        self.dict_items: List[Tuple[str, int, Any]] = []
+        # - for non-Expr fields: (key, None, value)
+        self.dict_items: List[Tuple[str, Optional[int], Any]] = []
         for key, val in d.items():
             if not isinstance(key, str):
                 raise excs.Error(f'Dictionary requires string keys, {key} has type {type(key)}')
@@ -35,11 +35,11 @@ class InlineDict(Expr):
                 self.dict_items.append((key, len(self.components), None))
                 self.components.append(val)
             else:
-                self.dict_items.append((key, -1, val))
+                self.dict_items.append((key, None, val))
 
         self.type_spec: Optional[Dict[str, ts.ColumnType]] = {}
         for key, idx, _ in self.dict_items:
-            if idx == -1:
+            if idx is None:
                 # TODO: implement type inference for values
                 self.type_spec = None
                 break
@@ -56,7 +56,7 @@ class InlineDict(Expr):
                 return f"'{val}'"
             return str(val)
         for key, idx, val in self.dict_items:
-            if idx != -1:
+            if idx is not None:
                 item_strs.append(f"'{key}': {str(self.components[i])}")
                 i += 1
             else:
@@ -71,7 +71,7 @@ class InlineDict(Expr):
 
     def to_dict(self) -> Dict[str, Any]:
         """Return the original dict used to construct this"""
-        return {key: val if idx == -1 else self.components[idx] for key, idx, val in self.dict_items}
+        return {key: val if idx is None else self.components[idx] for key, idx, val in self.dict_items}
 
     def sql_expr(self) -> Optional[sql.ClauseElement]:
         return None
@@ -80,7 +80,7 @@ class InlineDict(Expr):
         result = {}
         for key, idx, val in self.dict_items:
             assert isinstance(key, str)
-            if idx >= 0:
+            if idx is not None:
                 result[key] = data_row[self.components[idx].slot_idx]
             else:
                 result[key] = copy.deepcopy(val)
@@ -94,7 +94,9 @@ class InlineDict(Expr):
         assert 'dict_items' in d
         arg: Dict[str, Any] = {}
         for key, idx, val in d['dict_items']:
-            if idx >= 0:
+            # TODO Normalize idx -1 to None via schema migrations.
+            # Long-term we should not be allowing idx == -1.
+            if idx is not None and idx >= 0:  # Older schemas might have -1 instead of None
                 arg[key] = components[idx]
             else:
                 arg[key] = val

pixeltable/exprs/row_builder.py

@@ -60,6 +60,8 @@ class RowBuilder:
         Args:
             output_exprs: list of Exprs to be evaluated
             columns: list of columns to be materialized
+            input_exprs: list of Exprs that are excluded from evaluation (because they're already materialized)
+        TODO: enforce that output_exprs doesn't overlap with input_exprs?
         """
         self.unique_exprs = ExprSet()  # dependencies precede their dependents
         self.next_slot_idx = 0
@@ -179,12 +181,16 @@ class RowBuilder:
             for i, c in enumerate(expr.components):
                 # make sure we only refer to components that have themselves been recorded
                 expr.components[i] = self._record_unique_expr(c, True)
-        assert expr.slot_idx < 0
+        assert expr.slot_idx is None
         expr.slot_idx = self._next_slot_idx()
         self.unique_exprs.append(expr)
         return expr
 
     def _record_output_expr_id(self, e: Expr, output_expr_id: int) -> None:
+        assert e.slot_idx is not None
+        assert output_expr_id is not None
+        if e.slot_idx in self.input_expr_slot_idxs:
+            return
         self.output_expr_ids[e.slot_idx].add(output_expr_id)
         for d in e.dependencies():
             self._record_output_expr_id(d, output_expr_id)

pixeltable/exprs/similarity_expr.py

@@ -0,0 +1,65 @@
+from typing import Optional, List
+
+import sqlalchemy as sql
+import PIL.Image
+
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
+from .column_ref import ColumnRef
+from .data_row import DataRow
+from .expr import Expr
+from .literal import Literal
+from .row_builder import RowBuilder
+
+
+class SimilarityExpr(Expr):
+
+    def __init__(self, col_ref: ColumnRef, item: 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
+        idx_info = col_ref.col.get_idx_info()
+        if len(idx_info) == 0:
+            raise excs.Error(f'No index found for column {col_ref.col}')
+        if len(idx_info) > 1:
+            raise excs.Error(
+                f'Column {col_ref.col.name} has multiple indices; use the index name to disambiguate, '
+                f'e.g., `{col_ref.col.name}.<index-name>.similarity(...)`')
+        self.idx_info = next(iter(idx_info.values()))
+        idx = self.idx_info.idx
+
+        if item.col_type.is_string_type() and idx.txt_embed is None:
+            raise excs.Error(
+                f'Embedding index {self.idx_info.name} on column {self.idx_info.col.name} was created without the '
+                f'text_embed parameter and does not support text queries')
+        if item.col_type.is_image_type() and idx.img_embed is None:
+            raise excs.Error(
+                f'Embedding index {self.idx_info.name} on column {self.idx_info.col.name} was created without the '
+                f'img_embed parameter and does not support image queries')
+
+    def __str__(self) -> str:
+        return f'{self.components[0]}.similarity({self.components[1]})'
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        assert isinstance(self.components[1], Literal)
+        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)
+        item = self.components[1].val
+        return self.idx_info.idx.order_by_clause(self.idx_info.val_col, item, is_asc)
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        # this should never get called
+        assert False
+
+    @classmethod
+    def _from_dict(cls, d: dict, components: List[Expr]) -> Expr:
+        assert len(components) == 2
+        assert isinstance(components[0], ColumnRef)
+        return cls(components[0], components[1])

pixeltable/func/__init__.py

@@ -1,9 +1,7 @@
 from .aggregate_function import Aggregator, AggregateFunction, uda
-from .batched_function import BatchedFunction, ExplicitBatchedFunction
 from .callable_function import CallableFunction
 from .expr_template_function import ExprTemplateFunction
 from .function import Function
 from .function_registry import FunctionRegistry
-from .nos_function import NOSFunction
 from .signature import Signature, Parameter, Batch
 from .udf import udf, make_function, expr_udf

pixeltable/func/aggregate_function.py

@@ -72,6 +72,9 @@ class AggregateFunction(Function):
             if param.lower() in self.RESERVED_PARAMS:
                 raise excs.Error(f'{self.name}(): parameter name {param} is reserved')
 
+    def exec(self, *args: Any, **kwargs: Any) -> Any:
+        raise NotImplementedError
+
     def help_str(self) -> str:
         res = super().help_str()
         res += '\n\n' + inspect.getdoc(self.agg_cls.update)

pixeltable/func/callable_function.py

@@ -1,16 +1,12 @@
 from __future__ import annotations
 
 import inspect
-import sys
-from typing import Optional, Dict, Callable, List, Tuple
+from typing import Optional, Callable, Tuple, Any
 from uuid import UUID
+
 import cloudpickle
 
-import pixeltable.type_system as ts
-import pixeltable.exceptions as excs
 from .function import Function
-from .function_registry import FunctionRegistry
-from .globals import get_caller_module_path
 from .signature import Signature
 
 
@@ -24,13 +20,48 @@ class CallableFunction(Function):
 
     def __init__(
             self, signature: Signature, py_fn: Callable, self_path: Optional[str] = None,
-            self_name: Optional[str] = None):
+            self_name: Optional[str] = None, batch_size: Optional[int] = None):
         assert py_fn is not None
         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)
 
+    @property
+    def is_batched(self) -> bool:
+        return self.batch_size is not None
+
+    def exec(self, *args: Any, **kwargs: Any) -> Any:
+        if self.is_batched:
+            # Pack the batched parameters into singleton lists
+            constant_param_names = [p.name for p in self.signature.constant_parameters]
+            batched_args = [[arg] for arg in args]
+            constant_kwargs = {k: v for k, v in kwargs.items() if k in constant_param_names}
+            batched_kwargs = {k: [v] for k, v in kwargs.items() if k not in constant_param_names}
+            result = self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
+            assert len(result) == 1
+            return result[0]
+        else:
+            return self.py_fn(*args, **kwargs)
+
+    def exec_batch(self, *args: Any, **kwargs: Any) -> list:
+        """Execute the function with the given arguments and return the result.
+        The arguments are expected to be batched: if the corresponding parameter has type T,
+        then the argument should have type T if it's a constant parameter, or list[T] if it's
+        a batched parameter.
+        """
+        assert self.is_batched
+        # 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}
+        batched_kwargs = {k: v for k, v in kwargs.items() if k not in constant_param_names}
+        return self.py_fn(*args, **constant_kwargs, **batched_kwargs)
+
+    # TODO(aaron-siegel): Implement conditional batch sizing
+    def get_batch_size(self, *args: Any, **kwargs: Any) -> Optional[int]:
+        return self.batch_size
+
     @property
     def display_name(self) -> str:
         return self.self_name
@@ -44,7 +75,7 @@ class CallableFunction(Function):
         res += '\n\n' + inspect.getdoc(self.py_fn)
         return res
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         if self.self_path is None:
             # this is not a module function
             from .function_registry import FunctionRegistry
@@ -53,17 +84,30 @@ class CallableFunction(Function):
         return super()._as_dict()
 
     @classmethod
-    def _from_dict(cls, d: Dict) -> Function:
+    def _from_dict(cls, d: dict) -> Function:
         if 'id' in d:
             from .function_registry import FunctionRegistry
             return FunctionRegistry.get().get_stored_function(UUID(hex=d['id']))
         return super()._from_dict(d)
 
-    def to_store(self) -> Tuple[Dict, bytes]:
-        return (self.signature.as_dict(), cloudpickle.dumps(self.py_fn))
+    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
+        return md, cloudpickle.dumps(self.py_fn)
 
     @classmethod
-    def from_store(cls, name: Optional[str], md: Dict, binary_obj: bytes) -> Function:
+    def from_store(cls, name: 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)
+        return CallableFunction(Signature.from_dict(md), py_fn, self_name=name, batch_size=md.get('batch_size'))
+
+    def validate_call(self, bound_args: dict[str, Any]) -> None:
+        import pixeltable.exprs as exprs
+        if self.is_batched:
+            for param in self.signature.constant_parameters:
+                if param.name in bound_args and isinstance(bound_args[param.name], exprs.Expr):
+                    raise ValueError(
+                        f'{self.display_name}(): '
+                        f'parameter {param.name} must be a constant value, not a Pixeltable expression'
+                    )

pixeltable/func/expr_template_function.py

@@ -1,9 +1,8 @@
 import inspect
-from typing import Dict, Optional, Callable, List
+from typing import Dict, Optional, Any
 
 import pixeltable
 import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
 from .function import Function
 from .signature import Signature, Parameter
 
@@ -65,6 +64,16 @@ class ExprTemplateFunction(Function):
         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
+        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)
+        return row[row_builder.get_output_exprs()[0].slot_idx]
+
     @property
     def display_name(self) -> str:
         return self.self_name

pixeltable/func/function.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import abc
 import importlib
 import inspect
-import pixeltable
-from typing import Optional, Dict, Any, Tuple
+from typing import Optional, Dict, Any, Tuple, Callable
 
+import pixeltable
+import pixeltable.type_system as ts
 from .globals import resolve_symbol
 from .signature import Signature
 
@@ -18,10 +19,13 @@ 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, py_signature: inspect.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
 
     @property
     def name(self) -> str:
@@ -40,7 +44,7 @@ class Function(abc.ABC):
     def help_str(self) -> str:
         return self.display_name + str(self.signature)
 
-    def __call__(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.Expr':
+    def __call__(self, *args: Any, **kwargs: Any) -> 'pixeltable.exprs.Expr':
         from pixeltable import exprs
         bound_args = self.py_signature.bind(*args, **kwargs)
         self.validate_call(bound_args.arguments)
@@ -50,6 +54,33 @@ class Function(abc.ABC):
         """Override this to do custom validation of the arguments"""
         pass
 
+    def call_return_type(self, kwargs: dict[str, Any]) -> ts.ColumnType:
+        """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)
+        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]
+        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"""
+        # 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():
+            if param.name not in self.signature.parameters:
+                raise ValueError(f'`conditional_return_type` has parameter `{param.name}` that is not in the signature')
+        self._conditional_return_type = fn
+        return fn
+
+    @abc.abstractmethod
+    def exec(self, *args: Any, **kwargs: Any) -> Any:
+        """Execute the function with the given arguments and return the result."""
+        pass
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
             return False

pixeltable/func/signature.py

@@ -29,21 +29,12 @@ class Signature:
     """
     Represents the signature of a Pixeltable function.
 
-    Regarding return type:
-    - most functions will have a fixed return type, which is specified directly
-    - some functions will have a return type that depends on the argument values;
-      ex.: PIL.Image.Image.resize() returns an image with dimensions specified as a parameter
-    - in the latter case, the 'return_type' field is a function that takes the bound arguments and returns the
-      return type; if no bound arguments are specified, a generic return type is returned (eg, ImageType() without a
-      size)
     - self.is_batched: return type is a Batch[...] type
     """
     SPECIAL_PARAM_NAMES = ['group_by', 'order_by']
 
-    def __init__(
-            self,
-            return_type: Union[ts.ColumnType, Callable[[Dict[str, Any]], ts.ColumnType]],
-            parameters: List[Parameter], is_batched: bool = False):
+    def __init__(self, return_type: ts.ColumnType, parameters: List[Parameter], is_batched: bool = False):
+        assert isinstance(return_type, ts.ColumnType)
         self.return_type = return_type
         self.is_batched = is_batched
         # we rely on the ordering guarantee of dicts in Python >=3.7
@@ -52,10 +43,9 @@ class Signature:
         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]
 
-    def get_return_type(self, bound_args: Optional[Dict[str, Any]] = None) -> ts.ColumnType:
-        if isinstance(self.return_type, ts.ColumnType):
-            return self.return_type
-        return self.return_type(bound_args)
+    def get_return_type(self) -> ts.ColumnType:
+        assert isinstance(self.return_type, ts.ColumnType)
+        return self.return_type
 
     def as_dict(self) -> Dict[str, Any]:
         result = {