pixeltable 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

pixeltable/exprs/arithmetic_expr.py

@@ -1,28 +1,28 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple
+
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
-from .globals import ArithmeticOperator
-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 .globals import ArithmeticOperator
+from .row_builder import RowBuilder
+
 
 class ArithmeticExpr(Expr):
     """
     Allows arithmetic exprs on json paths
     """
     def __init__(self, operator: ArithmeticOperator, op1: Expr, op2: Expr):
-        # TODO: determine most specific common supertype
-        if op1.col_type.is_json_type() or op2.col_type.is_json_type():
+        if op1.col_type.is_json_type() or op2.col_type.is_json_type() or operator == ArithmeticOperator.DIV:
             # we assume it's a float
-            super().__init__(ts.FloatType())
+            super().__init__(ts.FloatType(nullable=(op1.col_type.nullable or op2.col_type.nullable)))
         else:
-            super().__init__(ts.ColumnType.supertype(op1.col_type, op2.col_type))
+            super().__init__(op1.col_type.supertype(op2.col_type))
         self.operator = operator
         self.components = [op1, op2]
 
@@ -43,7 +43,7 @@ class ArithmeticExpr(Expr):
     def _equals(self, other: ArithmeticExpr) -> bool:
         return self.operator == other.operator
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('operator', self.operator.value)]
 
     @property
@@ -55,6 +55,7 @@ class ArithmeticExpr(Expr):
         return self.components[1]
 
     def sql_expr(self) -> Optional[sql.ClauseElement]:
+        assert self.col_type.is_int_type() or self.col_type.is_float_type() or self.col_type.is_json_type()
         left = self._op1.sql_expr()
         right = self._op2.sql_expr()
         if left is None or right is None:
@@ -66,14 +67,31 @@ class ArithmeticExpr(Expr):
         if self.operator == ArithmeticOperator.MUL:
             return left * right
         if self.operator == ArithmeticOperator.DIV:
-            return left / right
+            assert self.col_type.is_float_type()
+            # We have to cast to a `float`, or else we'll get a `Decimal`
+            return sql.sql.expression.cast(left / right, sql.Float)
         if self.operator == ArithmeticOperator.MOD:
-            return left % right
+            if self.col_type.is_int_type():
+                return left % right
+            if self.col_type.is_float_type():
+                # Postgres does not support modulus for floats
+                return None
+        if self.operator == ArithmeticOperator.FLOORDIV:
+            # Postgres has a DIV operator, but it behaves differently from Python's // operator
+            # (Postgres rounds toward 0, Python rounds toward negative infinity)
+            # We need the behavior to be consistent, so that expressions will evaluate the same way
+            # whether or not their operands can be translated to SQL. These SQL clauses should
+            # mimic the behavior of Python's // operator.
+            if self.col_type.is_int_type():
+                return sql.sql.expression.cast(sql.func.floor(left / right), sql.Integer)
+            if self.col_type.is_float_type():
+                return sql.sql.expression.cast(sql.func.floor(left / right), sql.Float)
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         op1_val = data_row[self._op1.slot_idx]
         op2_val = data_row[self._op2.slot_idx]
-        # check types if we couldn't do that prior to execution
+
+        # if one or both columns is JsonTyped, we need a dynamic check that they are numeric
         if self._op1.col_type.is_json_type() and not isinstance(op1_val, int) and not isinstance(op1_val, float):
             raise excs.Error(
                 f'{self.operator} requires numeric type, but {self._op1} has type {type(op1_val).__name__}')
@@ -81,6 +99,11 @@ class ArithmeticExpr(Expr):
             raise excs.Error(
                 f'{self.operator} requires numeric type, but {self._op2} has type {type(op2_val).__name__}')
 
+        # if either operand is None, always return None
+        if op1_val is None or op2_val is None:
+            data_row[self.slot_idx] = None
+            return
+
         if self.operator == ArithmeticOperator.ADD:
             data_row[self.slot_idx] = op1_val + op2_val
         elif self.operator == ArithmeticOperator.SUB:
@@ -91,12 +114,14 @@ class ArithmeticExpr(Expr):
             data_row[self.slot_idx] = op1_val / op2_val
         elif self.operator == ArithmeticOperator.MOD:
             data_row[self.slot_idx] = op1_val % op2_val
+        elif self.operator == ArithmeticOperator.FLOORDIV:
+            data_row[self.slot_idx] = op1_val // op2_val
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'operator': self.operator.value, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> Expr:
         assert 'operator' in d
         assert len(components) == 2
         return cls(ArithmeticOperator(d['operator']), components[0], components[1])

pixeltable/exprs/expr.py

@@ -7,7 +7,6 @@ import inspect
 import json
 import sys
 import typing
-from itertools import islice
 from typing import Union, Optional, List, Callable, Any, Dict, Tuple, Set, Generator, Type
 from uuid import UUID
 
@@ -16,8 +15,8 @@ import sqlalchemy as sql
 import pixeltable
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
 import pixeltable.func as func
+import pixeltable.type_system as ts
 from .data_row import DataRow
 from .globals import ComparisonOperator, LogicalOperator, LiteralPythonTypes, ArithmeticOperator
 
@@ -91,8 +90,8 @@ class Expr(abc.ABC):
 
     def default_column_name(self) -> Optional[str]:
         """
-        Returns: 
-            None if this expression lacks a default name, 
+        Returns:
+            None if this expression lacks a default name,
             or a valid identifier (according to catalog.is_valid_identifer) otherwise.
         """
         return None
@@ -231,9 +230,8 @@ class Expr(abc.ABC):
             self.components[i] = self.components[i]._retarget(tbl_versions)
         return self
 
-    @abc.abstractmethod
     def __str__(self) -> str:
-        pass
+        return f'<Expression of type {type(self)}>'
 
     def display_str(self, inline: bool = True) -> str:
         """
@@ -264,7 +262,7 @@ class Expr(abc.ABC):
         if is_match:
             yield self
 
-    def contains(self, cls: Optional[Type[Expr]] = None, filter: Optional[Callable[[Expr], bool]] = None) -> bool:
+    def _contains(self, cls: Optional[Type[Expr]] = None, filter: Optional[Callable[[Expr], bool]] = None) -> bool:
         """
         Returns True if any subexpr is an instance of cls.
         """
@@ -319,17 +317,20 @@ class Expr(abc.ABC):
         """
         if isinstance(o, Expr):
             return o
-        # try to create a literal
+        # Try to create a literal. We need to check for InlineArray/InlineDict
+        # first, to prevent arrays from inappropriately being interpreted as JsonType
+        # literals.
+        # TODO: general cleanup of InlineArray/InlineDict
+        if isinstance(o, list):
+            from .inline_array import InlineArray
+            return InlineArray(tuple(o))
+        if isinstance(o, dict):
+            from .inline_dict import InlineDict
+            return InlineDict(o)
         obj_type = ts.ColumnType.infer_literal_type(o)
         if obj_type is not None:
             from .literal import Literal
             return Literal(o, col_type=obj_type)
-        if isinstance(o, dict):
-            from .inline_dict import InlineDict
-            return InlineDict(o)
-        elif isinstance(o, list):
-            from .inline_array import InlineArray
-            return InlineArray(tuple(o))
         return None
 
     @abc.abstractmethod
@@ -427,6 +428,14 @@ class Expr(abc.ABC):
         # Return a `FunctionCall` obtained by passing this `Expr` to the new `function`.
         return function(self)
 
+    def __dir__(self) -> list[str]:
+        attrs = ['isin', 'astype', 'apply']
+        attrs += [
+            f.name
+            for f in func.FunctionRegistry.get().get_type_methods(self.col_type.type_enum)
+        ]
+        return attrs
+
     def __getitem__(self, index: object) -> Expr:
         if self.col_type.is_json_type():
             from .json_path import JsonPath
@@ -434,19 +443,23 @@ class Expr(abc.ABC):
         if self.col_type.is_array_type():
             from .array_slice import ArraySlice
             return ArraySlice(self, index)
-        raise excs.Error(f'Type {self.col_type} is not subscriptable')
+        raise AttributeError(f'Type {self.col_type} is not subscriptable')
 
-    def __getattr__(self, name: str) -> Union['pixeltable.exprs.ImageMemberAccess', 'pixeltable.exprs.JsonPath']:
+    def __getattr__(self, name: str) -> Union['pixeltable.exprs.MethodRef', 'pixeltable.exprs.FunctionCall', 'pixeltable.exprs.JsonPath']:
         """
         ex.: <img col>.rotate(60)
         """
-        if self.col_type.is_image_type():
-            from .image_member_access import ImageMemberAccess
-            return ImageMemberAccess(name, self)
         if self.col_type.is_json_type():
-            from .json_path import JsonPath
-            return JsonPath(self).__getattr__(name)
-        raise excs.Error(f'Member access not supported on type {self.col_type}: {name}')
+            return pixeltable.exprs.JsonPath(self).__getattr__(name)
+        else:
+            method_ref = pixeltable.exprs.MethodRef(self, name)
+            if method_ref.fn.is_property:
+                # Marked as a property, so autoinvoke the method to obtain a `FunctionCall`
+                assert method_ref.fn.arity == 1
+                return method_ref.fn(method_ref.base_expr)
+            else:
+                # Return the `MethodRef` object itself; it requires arguments to become a `FunctionCall`
+                return method_ref
 
     def __bool__(self) -> bool:
         raise TypeError(
@@ -490,6 +503,9 @@ class Expr(abc.ABC):
             return Comparison(op, self, Literal(other))  # type: ignore[arg-type]
         raise TypeError(f'Other must be Expr or literal: {type(other)}')
 
+    def __neg__(self) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._make_arithmetic_expr(ArithmeticOperator.MUL, -1)
+
     def __add__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.ADD, other)
 
@@ -505,6 +521,27 @@ class Expr(abc.ABC):
     def __mod__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.MOD, other)
 
+    def __floordiv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._make_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
+
+    def __radd__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.ADD, other)
+
+    def __rsub__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.SUB, other)
+
+    def __rmul__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.MUL, other)
+
+    def __rtruediv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.DIV, other)
+
+    def __rmod__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.MOD, other)
+
+    def __rfloordiv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
+
     def _make_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
         """
         other: Union[Expr, LiteralPythonTypes]
@@ -518,6 +555,19 @@ class Expr(abc.ABC):
             return ArithmeticExpr(op, self, Literal(other))  # type: ignore[arg-type]
         raise TypeError(f'Other must be Expr or literal: {type(other)}')
 
+    def _rmake_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        """
+        Right-handed version of _make_arithmetic_expr. other must be a literal; if it were an Expr,
+        the operation would have already been evaluated in its left-handed form.
+        """
+        # TODO: check for compatibility
+        from .arithmetic_expr import ArithmeticExpr
+        from .literal import Literal
+        assert not isinstance(other, Expr)  # Else the left-handed form would have evaluated first
+        if isinstance(other, typing.get_args(LiteralPythonTypes)):
+            return ArithmeticExpr(op, Literal(other), self)  # type: ignore[arg-type]
+        raise TypeError(f'Other must be Expr or literal: {type(other)}')
+
     def __and__(self, other: object) -> Expr:
         if not isinstance(other, Expr):
             raise TypeError(f'Other needs to be an expression: {type(other)}')

pixeltable/exprs/function_call.py

@@ -20,6 +20,22 @@ from .rowid_ref import RowidRef
 
 
 class FunctionCall(Expr):
+
+    fn: func.Function
+    is_method_call: bool
+    agg_init_args: Dict[str, Any]
+    args: List[Tuple[Optional[int], Optional[Any]]]
+    kwargs: Dict[str, Tuple[Optional[int], Optional[Any]]]
+    arg_types: List[ts.ColumnType]
+    kwarg_types: Dict[str, ts.ColumnType]
+    group_by_start_idx: int
+    group_by_stop_idx: int
+    fn_expr_idx: int
+    order_by_start_idx: int
+    constant_args: set[str]
+    aggregator: Optional[Any]
+    current_partition_vals: Optional[List[Any]]
+
     def __init__(
             self, fn: func.Function, bound_args: Dict[str, Any], order_by_clause: Optional[List[Any]] = None,
             group_by_clause: Optional[List[Any]] = None, is_method_call: bool = False):
@@ -31,9 +47,9 @@ class FunctionCall(Expr):
         super().__init__(fn.call_return_type(bound_args))
         self.fn = fn
         self.is_method_call = is_method_call
-        self.check_args(signature, bound_args)
+        self.normalize_args(signature, bound_args)
 
-        self.agg_init_args: Dict[str, Any] = {}
+        self.agg_init_args = {}
         if self.is_agg_fn_call:
             # we separate out the init args for the aggregator
             self.agg_init_args = {
@@ -42,17 +58,16 @@ class FunctionCall(Expr):
             bound_args = {arg_name: arg for arg_name, arg in bound_args.items() if arg_name not in fn.init_param_names}
 
         # construct components, args, kwargs
-        self.components: List[Expr] = []
 
         # Tuple[int, Any]:
         # - for Exprs: (index into components, None)
         # - otherwise: (None, val)
-        self.args: List[Tuple[Optional[int], Optional[Any]]] = []
-        self.kwargs: Dict[str, Tuple[Optional[int], Optional[Any]]] = {}
+        self.args = []
+        self.kwargs = {}
 
         # we record the types of non-variable parameters for runtime type checks
-        self.arg_types: List[ts.ColumnType] = []
-        self.kwarg_types: Dict[str, ts.ColumnType] = {}
+        self.arg_types = []
+        self.kwarg_types = {}
         # the prefix of parameters that are bound can be passed by position
         for param in fn.signature.py_signature.parameters.values():
             if param.name not in bound_args or param.kind == inspect.Parameter.KEYWORD_ONLY:
@@ -111,8 +126,8 @@ class FunctionCall(Expr):
 
         self.constant_args = {param_name for param_name, arg in bound_args.items() if not isinstance(arg, Expr)}
         # execution state for aggregate functions
-        self.aggregator: Optional[Any] = None
-        self.current_partition_vals: Optional[List[Any]] = None
+        self.aggregator = None
+        self.current_partition_vals = None
 
         self.id = self._create_id()
 
@@ -120,26 +135,37 @@ class FunctionCall(Expr):
         target = tbl._tbl_version_path.tbl_version
         return [RowidRef(target, i) for i in range(target.num_rowid_columns())]
 
+    def default_column_name(self) -> Optional[str]:
+        if self.fn.is_property:
+            return self.fn.name
+        return super().default_column_name()
+
     @classmethod
-    def check_args(cls, signature: func.Signature, bound_args: Dict[str, Any]) -> None:
-        """Checks that bound_args are compatible with signature.
+    def normalize_args(cls, signature: func.Signature, bound_args: Dict[str, Any]) -> None:
+        """Converts all args to Exprs and checks that they are compatible with signature.
 
-        Convert literals to the correct type and update bound_args in place, if necessary.
+        Updates bound_args in place, where necessary.
         """
         for param_name, arg in bound_args.items():
             param = signature.parameters[param_name]
+            is_var_param = param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+
             if isinstance(arg, dict):
                 try:
                     arg = InlineDict(arg)
                     bound_args[param_name] = arg
+                    continue
                 except excs.Error:
                     # this didn't work, but it might be a literal
                     pass
+
             if isinstance(arg, list) or isinstance(arg, tuple):
                 try:
                     # If the column type is JsonType, force the literal to be JSON
-                    arg = InlineArray(arg, force_json=param.col_type is not None and param.col_type.is_json_type())
+                    is_json = is_var_param or (param.col_type is not None and param.col_type.is_json_type())
+                    arg = InlineArray(arg, force_json=is_json)
                     bound_args[param_name] = arg
+                    continue
                 except excs.Error:
                     # this didn't work, but it might be a literal
                     pass
@@ -149,30 +175,39 @@ class FunctionCall(Expr):
                 try:
                     _ = json.dumps(arg)
                 except TypeError:
-                    raise excs.Error(f"Argument for parameter '{param_name}' is not json-serializable: {arg}")
+                    raise excs.Error(f'Argument for parameter {param_name!r} is not json-serializable: {arg}')
                 if arg is not None:
                     try:
                         param_type = param.col_type
                         bound_args[param_name] = param_type.create_literal(arg)
                     except TypeError as e:
                         msg = str(e)
-                        raise excs.Error(f"Argument for parameter '{param_name}': {msg[0].lower() + msg[1:]}")
+                        raise excs.Error(f'Argument for parameter {param_name!r}: {msg[0].lower() + msg[1:]}')
                 continue
 
-            # variable parameters don't get type-checked, but they both need to be json-typed
-            if param.kind == inspect.Parameter.VAR_POSITIONAL:
-                assert isinstance(arg, InlineArray)
-                arg.col_type = ts.JsonType()
-                continue
-            if param.kind == inspect.Parameter.VAR_KEYWORD:
-                assert isinstance(arg, InlineDict)
-                arg.col_type = ts.JsonType()
-            continue
-
-            if not param_type.is_supertype_of(arg.col_type):
-                raise excs.Error(
-                    f'Parameter {param_name}: argument type {arg.col_type} does not match parameter type '
-                    f'{param_type}')
+            # these checks break the db migration test, because InlineArray isn't serialized correctly (it looses
+            # the type information)
+            # if is_var_param:
+            #     if param.kind == inspect.Parameter.VAR_POSITIONAL:
+            #         if not isinstance(arg, InlineArray) or not arg.col_type.is_json_type():
+            #             pass
+            #         assert isinstance(arg, InlineArray), type(arg)
+            #         assert arg.col_type.is_json_type()
+            #     if param.kind == inspect.Parameter.VAR_KEYWORD:
+            #         if not isinstance(arg, InlineDict):
+            #             pass
+            #         assert isinstance(arg, InlineDict), type(arg)
+            if is_var_param:
+                pass
+            else:
+                assert param.col_type is not None
+                # Check that the argument is consistent with the expected parameter type, with the allowance that
+                # non-nullable parameters can still accept nullable arguments (since function calls with Nones
+                # assigned to non-nullable parameters will always return None)
+                if not param.col_type.is_supertype_of(arg.col_type, ignore_nullable=True):
+                    raise excs.Error(
+                        f'Parameter {param_name}: argument type {arg.col_type} does not match parameter type '
+                        f'{param.col_type}')
 
     def _equals(self, other: FunctionCall) -> bool:
         if self.fn != other.fn:

pixeltable/exprs/globals.py

@@ -29,6 +29,8 @@ class ComparisonOperator(enum.Enum):
             return '<='
         if self == self.EQ:
             return '=='
+        if self == self.NE:
+            return '!='
         if self == self.GT:
             return '>'
         if self == self.GE:
@@ -66,6 +68,7 @@ class ArithmeticOperator(enum.Enum):
     MUL = 2
     DIV = 3
     MOD = 4
+    FLOORDIV = 5
 
     def __str__(self) -> str:
         if self == self.ADD:
@@ -78,4 +81,5 @@ class ArithmeticOperator(enum.Enum):
             return '/'
         if self == self.MOD:
             return '%'
-
+        if self == self.FLOORDIV:
+            return '//'

pixeltable/exprs/inline_array.py

@@ -21,6 +21,9 @@ class InlineArray(Expr):
     is `True`, it will always be cast as a `JsonType`. If `force_json` is `False`, it will be cast as an
     `ArrayType` if it is a homogenous array of scalars or arrays, or a `JsonType` otherwise.
     """
+
+    elements: List[Tuple[Optional[int], Any]]
+
     def __init__(self, elements: Tuple, force_json: bool = False):
         # we need to call this in order to populate self.components
         super().__init__(ts.ArrayType((len(elements),), ts.IntType()))
@@ -28,7 +31,7 @@ class InlineArray(Expr):
         # elements contains
         # - for Expr elements: (index into components, None)
         # - for non-Expr elements: (None, value)
-        self.elements: List[Tuple[Optional[int], Any]] = []
+        self.elements = []
         for el in elements:
             el = copy.deepcopy(el)
             if isinstance(el, list):
@@ -43,14 +46,16 @@ class InlineArray(Expr):
             else:
                 self.elements.append((None, el))
 
-        inferred_element_type = ts.InvalidType()
-        for idx, val in self.elements:
-            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))
-            if inferred_element_type is None:
-                break
+        inferred_element_type: Optional[ts.ColumnType] = ts.InvalidType()
+        if not force_json:
+            # try to infer the element type
+            for idx, val in self.elements:
+                if idx is not None:
+                    inferred_element_type = inferred_element_type.supertype(self.components[idx].col_type)
+                else:
+                    inferred_element_type = inferred_element_type.supertype(ts.ColumnType.infer_literal_type(val))
+                if inferred_element_type is None:
+                    break
 
         if force_json or inferred_element_type is None:
             # JSON conversion is forced, or there is no common supertype
@@ -93,7 +98,7 @@ class InlineArray(Expr):
             data_row[self.slot_idx] = result
 
     def _as_dict(self) -> Dict:
-        return {'elements': self.elements, **super()._as_dict()}
+        return {'elements': self.elements, 'is_json': self.col_type.is_json_type(), **super()._as_dict()}
 
     @classmethod
     def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
@@ -106,4 +111,6 @@ class InlineArray(Expr):
                 arg.append(components[idx])
             else:
                 arg.append(val)
-        return cls(tuple(arg))
+        # in order to avoid a schema version change, we'll interpret the absence of 'is_json' to indicate an ArrayType
+        is_json = d.get('is_json', False)
+        return cls(tuple(arg), force_json=is_json)

pixeltable/exprs/method_ref.py

@@ -0,0 +1,63 @@
+from typing import Any, Optional
+
+import sqlalchemy as sql
+
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
+from pixeltable.exprs import Expr, FunctionCall
+from pixeltable.func import FunctionRegistry, CallableFunction
+from .data_row import DataRow
+from .row_builder import RowBuilder
+
+
+class MethodRef(Expr):
+    """
+    A method reference. This represents a `Function` instance with its
+    first parameter bound to a base expression.
+
+    When a `MethodRef` is called, it returns a `FunctionCall` with the base expression as the first argument.
+    The effective arity of a `MethodRef` is one less than the arity of the underlying `Function`.
+    """
+    # TODO: Should this even be an `Expr`? It can't actually be evaluated directly (it has to be first
+    #   converted to a `FunctionCall` by binding any remaining parameters).
+
+    def __init__(self, base_expr: Expr, method_name: str):
+        super().__init__(ts.InvalidType())  # The `MethodRef` is untyped until it is called.
+        self.base_expr = base_expr
+        self.method_name = method_name
+        self.fn = FunctionRegistry.get().lookup_type_method(base_expr.col_type.type_enum, method_name)
+        if self.fn is None:
+            # This has to be an `AttributeError`, or tab-completion won't work properly in ipython.
+            raise AttributeError(f'Unknown method (of type {base_expr.col_type}): {method_name}')
+        self.components = [base_expr]
+        self.id = self._create_id()
+
+    def _as_dict(self) -> dict:
+        return {'method_name': self.method_name, **super()._as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: dict, components: list[Expr]) -> Expr:
+        assert 'method_name' in d
+        assert len(components) == 1
+        return cls(d['method_name'], components[0])
+
+    def __call__(self, *args, **kwargs) -> FunctionCall:
+        result = self.fn(*[self.base_expr, *args], **kwargs)
+        assert isinstance(result, FunctionCall)
+        result.is_method_call = True
+        return result
+
+    def _equals(self, other: 'MethodRef') -> bool:
+        return self.base_expr == other.base_expr and self.method_name == other.method_name
+
+    def _id_attrs(self) -> list[tuple[str, Any]]:
+        return super()._id_attrs() + [('method_name', self.method_name)]
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        return None
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        assert False, 'MethodRef cannot be evaluated directly'
+
+    def __str__(self) -> str:
+        return f'{self.base_expr}.{self.method_name}'

pixeltable/ext/__init__.py

@@ -3,3 +3,12 @@ Extended integrations for Pixeltable. This package contains experimental or demo
 are not intended for production use. Long-term support cannot be guaranteed, usually because the features
 have dependencies whose future support is unclear.
 """
+
+from pixeltable.utils.code import local_public_names
+from . import functions
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__():
+    return __all__

pixeltable/ext/functions/__init__.py

@@ -0,0 +1,8 @@
+from pixeltable.utils.code import local_public_names
+from . import whisperx, yolox
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__():
+    return __all__