pixeltable 0.0.0__py3-none-any.whl

pixeltable/func/__init__.py

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

pixeltable/func/aggregate_function.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import abc
+import importlib
+import inspect
+from typing import Optional, Any, Type, List, Dict, Callable
+import itertools
+
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
+from .function import Function
+from .signature import Signature, Parameter
+from .globals import validate_symbol_path
+
+
+class Aggregator(abc.ABC):
+    def update(self, *args: Any, **kwargs: Any) -> None:
+        pass
+    def value(self) -> Any:
+        pass
+
+
+class AggregateFunction(Function):
+    """Function interface for an aggregation operation.
+
+    requires_order_by: if True, the first parameter to an aggregate function defines the order in which the function
+    sees rows in update()
+    allows_std_agg: if True, the aggregate function can be used as a standard aggregate function w/o a window
+    allows_window: if True, the aggregate function can be used with a window
+    """
+    ORDER_BY_PARAM = 'order_by'
+    GROUP_BY_PARAM = 'group_by'
+    RESERVED_PARAMS = {ORDER_BY_PARAM, GROUP_BY_PARAM}
+
+    def __init__(
+            self, aggregator_class: Type[Aggregator], self_path: str,
+            init_types: List[ts.ColumnType], update_types: List[ts.ColumnType], value_type: ts.ColumnType,
+            requires_order_by: bool, allows_std_agg: bool, allows_window: bool):
+        self.agg_cls = aggregator_class
+        self.requires_order_by = requires_order_by
+        self.allows_std_agg = allows_std_agg
+        self.allows_window = allows_window
+
+        # 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)
+        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)
+        ]
+        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 = [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)
+        self.init_param_names = [p.name for p in init_params]
+
+        # make sure the signature doesn't contain reserved parameter names;
+        # do this after super().__init__(), otherwise self.name is invalid
+        for param in signature.parameters:
+            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)
+        return res
+
+    def __call__(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.Expr':
+        from pixeltable import exprs
+
+        # perform semantic analysis of special parameters 'order_by' and 'group_by'
+        order_by_clause: Optional[Any] = None
+        if self.ORDER_BY_PARAM in kwargs:
+            if self.requires_order_by:
+                raise excs.Error(
+                    f'{self.display_name}(): order_by invalid, this function requires the first argument to be the '
+                    f'ordering expression'
+                )
+            if not self.allows_window:
+                raise excs.Error(
+                    f'{self.display_name}(): order_by invalid with an aggregate function that does not allow windows')
+            order_by_clause = kwargs.pop(self.ORDER_BY_PARAM)
+        elif self.requires_order_by:
+            # the first argument is the order-by expr
+            if len(args) == 0:
+                raise excs.Error(f'{self.display_name}(): requires an ordering expression as its first argument')
+            order_by_clause = args[0]
+            if not isinstance(order_by_clause, exprs.Expr):
+                raise excs.Error(
+                    f'{self.display_name}(): the first argument needs to be a Pixeltable expression, but instead is a '
+                    f'{type(order_by_clause)}'
+                )
+            # don't pass the first parameter on, the Function doesn't get to see it
+            args = args[1:]
+
+        group_by_clause: Optional[Any] = None
+        if self.GROUP_BY_PARAM in kwargs:
+            if not self.allows_window:
+                raise excs.Error(
+                    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)
+        self.validate_call(bound_args.arguments)
+        return exprs.FunctionCall(
+            self, bound_args.arguments,
+            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)
+        import pixeltable.exprs as exprs
+        for param_name in self.init_param_names:
+            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'
+                )
+
+
+def uda(
+        *,
+        value_type: ts.ColumnType,
+        update_types: List[ts.ColumnType],
+        init_types: Optional[List[ts.ColumnType]] = None,
+        requires_order_by: bool = False, allows_std_agg: bool = True, allows_window: bool = False,
+) -> Callable:
+    """Decorator for user-defined aggregate functions.
+
+    The decorated class must inherit from Aggregator and implement the following methods:
+    - __init__(self, ...) to initialize the aggregator
+    - update(self, ...) to update the aggregator with a new value
+    - value(self) to return the final result
+
+    The decorator creates an AggregateFunction instance from the class and adds it
+    to the module where the class is defined.
+
+    Parameters:
+    - init_types: list of types for the __init__() parameters; must match the number of parameters
+    - update_types: list of types for the update() parameters; must match the number of parameters
+    - value_type: return type of the aggregator
+    - requires_order_by: if True, the first parameter to the function is the order-by expression
+    - allows_std_agg: if True, the function can be used as a standard aggregate function w/o a window
+    - allows_window: if True, the function can be used with a window
+    """
+    if init_types is None:
+        init_types = []
+
+    def decorator(cls: Type[Aggregator]) -> Type[Function]:
+        # validate type parameters
+        num_init_params = len(inspect.signature(cls.__init__).parameters) - 1
+        if num_init_params > 0:
+            if len(init_types) != num_init_params:
+                raise excs.Error(
+                    f'init_types must be a list of {num_init_params} types, one for each parameter of __init__()')
+        num_update_params = len(inspect.signature(cls.update).parameters) - 1
+        if num_update_params == 0:
+            raise excs.Error('update() must have at least one parameter')
+        if len(update_types) != num_update_params:
+            raise excs.Error(
+                f'update_types must be a list of {num_update_params} types, one for each parameter of update()')
+        assert value_type is not None
+
+        # the AggregateFunction instance resides in the same module as cls
+        class_path = f'{cls.__module__}.{cls.__qualname__}'
+        # nonlocal name
+        # name = name or cls.__name__
+        # instance_path_elements = class_path.split('.')[:-1] + [name]
+        # instance_path = '.'.join(instance_path_elements)
+
+        # create the corresponding AggregateFunction instance
+        instance = AggregateFunction(
+            cls, class_path, init_types, update_types, value_type, requires_order_by, allows_std_agg, allows_window)
+        # do the path validation at the very end, in order to be able to write tests for the other failure cases
+        validate_symbol_path(class_path)
+        #module = importlib.import_module(cls.__module__)
+        #setattr(module, name, instance)
+
+        return instance
+
+    return decorator

pixeltable/func/callable_function.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import inspect
+from typing import Optional, Callable, Tuple, Any
+from uuid import UUID
+
+import cloudpickle
+
+from .function import Function
+from .signature import Signature
+
+
+class CallableFunction(Function):
+    """Pixeltable Function backed by a Python Callable.
+
+    CallableFunctions come in two flavors:
+    - references to lambdas and functions defined in notebooks, which are pickled and serialized to the store
+    - functions that are defined in modules are serialized via the default mechanism
+    """
+
+    def __init__(
+            self, signature: Signature, py_fn: Callable, self_path: 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
+
+    @property
+    def name(self) -> str:
+        return self.self_name
+
+    def help_str(self) -> str:
+        res = super().help_str()
+        res += '\n\n' + inspect.getdoc(self.py_fn)
+        return res
+
+    def _as_dict(self) -> dict:
+        if self.self_path is None:
+            # this is not a module function
+            from .function_registry import FunctionRegistry
+            id = FunctionRegistry.get().create_stored_function(self)
+            return {'id': id.hex}
+        return super()._as_dict()
+
+    @classmethod
+    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]:
+        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:
+        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'))
+
+    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

@@ -0,0 +1,99 @@
+import inspect
+from typing import Dict, Optional, Any
+
+import pixeltable
+import pixeltable.exceptions as excs
+from .function import Function
+from .signature import Signature, Parameter
+
+
+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,
+            name: Optional[str] = None):
+        import pixeltable.exprs as exprs
+        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}
+
+        # 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:
+                continue
+            param_expr = self.param_exprs_by_name[py_param.name]
+            try:
+                literal_default = exprs.Literal(py_param.default, col_type=param_expr.col_type)
+                self.defaults[py_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)
+
+        super().__init__(signature, py_signature=py_signature, self_path=self_path)
+
+    def instantiate(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.Expr':
+        bound_args = self.py_signature.bind(*args, **kwargs).arguments
+        # apply defaults, otherwise we might have Parameters left over
+        bound_args.update(
+            {param_name: default for param_name, default in self.defaults.items() if param_name not in bound_args})
+        result = self.expr.copy()
+        import pixeltable.exprs as exprs
+        for param_name, arg in bound_args.items():
+            param_expr = self.param_exprs_by_name[param_name]
+            if not isinstance(arg, exprs.Expr):
+                # TODO: use the available param_expr.col_type
+                arg_expr = exprs.Expr.from_object(arg)
+                if arg_expr is None:
+                    raise excs.Error(f'{self.self_name}(): cannot convert argument {arg} to a Pixeltable expression')
+            else:
+                arg_expr = arg
+            result = result.substitute(param_expr, arg_expr)
+        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
+        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
+
+    @property
+    def name(self) -> str:
+        return self.self_name
+
+    def _as_dict(self) -> Dict:
+        if self.self_path is not None:
+            return super()._as_dict()
+        return {
+            'name': self.name,
+            'expr': self.expr.as_dict(),
+            **super()._as_dict()
+        }
+
+    @classmethod
+    def _from_dict(cls, d: Dict) -> Function:
+        if 'expr' not in d:
+            return super()._from_dict(d)
+        import pixeltable.exprs as exprs
+        return cls(exprs.Expr.from_dict(d['expr']), name=d['name'])

pixeltable/func/function.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import abc
+import importlib
+import inspect
+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
+
+
+class Function(abc.ABC):
+    """Base class for Pixeltable's function interface.
+
+    A function in Pixeltable is an object that has a signature and implements __call__().
+    This base class provides a default serialization mechanism for Function instances provided by Python modules,
+    via the member self_path.
+    """
+
+    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:
+        assert self.self_path is not None
+        return self.self_path.split('.')[-1]
+
+    @property
+    def display_name(self) -> str:
+        if self.self_path is None:
+            return '<anonymous>'
+        ptf_prefix = 'pixeltable.functions.'
+        if self.self_path.startswith(ptf_prefix):
+            return self.self_path[len(ptf_prefix):]
+        return self.self_path
+
+    def help_str(self) -> str:
+        return self.display_name + str(self.signature)
+
+    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)
+        return exprs.FunctionCall(self, bound_args.arguments)
+
+    def validate_call(self, bound_args: Dict[str, Any]) -> None:
+        """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
+        return self.self_path == other.self_path
+
+    def source(self) -> None:
+        """Print source code"""
+        print('source not available')
+
+    def as_dict(self) -> Dict:
+        """
+        Return a serialized reference to the instance that can be passed to json.dumps() and converted back
+        to an instance with from_dict().
+        Subclasses can override _as_dict().
+        """
+        classpath = f'{self.__class__.__module__}.{self.__class__.__qualname__}'
+        return {'_classpath': classpath, **self._as_dict()}
+
+    def _as_dict(self) -> Dict:
+        """Default serialization: store the path to self (which includes the module path)"""
+        assert self.self_path is not None
+        return {'path': self.self_path}
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> Function:
+        """
+        Turn dict that was produced by calling as_dict() into an instance of the correct Function subclass.
+        """
+        assert '_classpath' in d
+        module_path, class_name = d['_classpath'].rsplit('.', 1)
+        class_module = importlib.import_module(module_path)
+        func_class = getattr(class_module, class_name)
+        return func_class._from_dict(d)
+
+    @classmethod
+    def _from_dict(cls, d: Dict) -> Function:
+        """Default deserialization: load the symbol indicated by the stored symbol_path"""
+        assert 'path' in d and d['path'] is not None
+        instance = resolve_symbol(d['path'])
+        assert isinstance(instance, Function)
+        return instance
+
+    def to_store(self) -> Tuple[Dict, bytes]:
+        """
+        Serialize the function to a format that can be stored in the Pixeltable store
+        Returns:
+            - a dict that can be passed to json.dumps()
+            - additional binary data
+        Only Function subclasses that can be stored need to override this.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def from_store(cls, name: Optional[str], md: Dict, binary_obj: bytes) -> Function:
+        """
+        Create a Function instance from the serialized representation returned by to_store()
+        """
+        raise NotImplementedError()