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

pixeltable/func/expr_template_function.py

@@ -1,52 +1,75 @@
-import inspect
-from typing import Any, Optional
+from typing import Any, Sequence
 
-import pixeltable
-import pixeltable.exceptions as excs
+from pixeltable import exceptions as excs, exprs, type_system as ts
 
 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: 'exprs.Expr'
+    signature: Signature
+    param_exprs: dict[str, 'exprs.Variable']
 
-    def __init__(
-            self, expr: 'pixeltable.exprs.Expr', signature: Signature, self_path: Optional[str] = None,
-            name: Optional[str] = None):
-        import pixeltable.exprs as exprs
+    def __init__(self, expr: 'exprs.Expr', signature: Signature):
         self.expr = expr
-        self.self_name = name
-        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))
-        self.param_exprs_by_name = {p.name: p for p in self.param_exprs}
+        self.signature = signature
+
+        self.param_exprs = {name: exprs.Variable(name, param.col_type) for name, param in signature.parameters.items()}
+
+        # validate that all variables in the expression are parameters
+        for var in expr.subexprs(expr_class=exprs.Variable):
+            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
-        for param in signature.parameters.values():
-            if param.default is inspect.Parameter.empty:
+        self.defaults: dict[str, exprs.Literal] = {}
+        for param in self.signature.parameters.values():
+            if param.default is None:
                 continue
-            param_expr = self.param_exprs_by_name[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
+
+    # def __repr__(self) -> str:
+    #     return f'ExprTemplate(expr={repr(self.expr)}, signature={self.signature})'
+
+
+class ExprTemplateFunction(Function):
+    """A parameterized expression from which an executable Expr is created with a function call."""
 
-        super().__init__(signature, self_path=self_path)
+    templates: list[ExprTemplate]
+    self_name: str
 
-    def instantiate(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.Expr':
+    def __init__(self, templates: list[ExprTemplate], self_path: str | None = None, name: str | None = 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]) -> 'exprs.Expr':
+        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
+        # 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[param_name]
             if not isinstance(arg, exprs.Expr):
                 # TODO: use the available param_expr.col_type
                 arg_expr = exprs.Expr.from_object(arg)
@@ -56,44 +79,74 @@ 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 call_return_type(self, bound_args: dict[str, 'exprs.Expr']) -> ts.ColumnType:
+        """
+        The call_return_type of an ExprTemplateFunction is derived from the template expression's col_type after
+        substitution (unlike for UDFs, whose call_return_type is derived from an explicitly specified
+        conditional_return_type).
+        """
+        assert not self.is_polymorphic
+        with_defaults = bound_args.copy()
+        with_defaults.update(
+            {
+                param_name: default
+                for param_name, default in self.template.defaults.items()
+                if param_name not in bound_args
+            }
+        )
+        substituted_expr = self.template.expr.copy().substitute(
+            {self.template.param_exprs[name]: expr for name, expr in with_defaults.items()}
+        )
+        return substituted_expr.col_type
+
+    def comment(self) -> str | None:
+        if isinstance(self.templates[0].expr, exprs.FunctionCall):
+            return self.templates[0].expr.fn.comment()
+        return None
+
+    def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
+        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 = row_builder.make_row()
         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:
+        if not self.self_name and isinstance(self.templates[0].expr, exprs.FunctionCall):
+            # In the common case where the templated expression is itself a FunctionCall,
+            # fall back on the display name of the underlying FunctionCall
+            return self.templates[0].expr.fn.display_name
         return self.self_name
 
     @property
     def name(self) -> str:
         return self.self_name
 
+    @property
+    def is_async(self) -> bool:
+        return False
+
     def __str__(self) -> str:
-        return str(self.expr)
+        return str(self.templates[0].expr)
+
+    # def __repr__(self) -> str:
+    #     return f'ExprTemplateFunction(name={self.name}, templates={self.templates})'
 
     def _as_dict(self) -> dict:
         if self.self_path is not None:
             return super()._as_dict()
-        return {
-            'expr': self.expr.as_dict(),
-            'signature': self.signature.as_dict(),
-            'name': self.name,
-        }
+        assert not self.is_polymorphic
+        assert len(self.templates) == 1
+        return {'expr': self.template.expr.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']), 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'])