pixeltable 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

pixeltable/exprs/function_call.py

@@ -205,6 +205,10 @@ class FunctionCall(Expr):
     def has_group_by(self) -> bool:
         return self.group_by_stop_idx != 0
 
+    @property
+    def is_async(self) -> bool:
+        return self.fn.is_async
+
     @property
     def group_by(self) -> list[Expr]:
         return self.components[self.group_by_start_idx : self.group_by_stop_idx]
@@ -272,6 +276,34 @@ class FunctionCall(Expr):
         assert isinstance(self.fn, func.AggregateFunction)
         self.aggregator = self.fn.agg_class(**self.agg_init_args)
 
+    @property
+    def bound_args(self) -> dict[str, Expr]:
+        """
+        Reconstructs bound arguments from the components of this FunctionCall.
+        """
+        bound_args: dict[str, Expr] = {}
+        for name, idx in self.bound_idxs.items():
+            if isinstance(idx, int):
+                bound_args[name] = self.components[idx]
+            elif isinstance(idx, Sequence):
+                bound_args[name] = Expr.from_object([self.components[i] for i in idx])
+            elif isinstance(idx, dict):
+                bound_args[name] = Expr.from_object({k: self.components[i] for k, i in idx.items()})
+            else:
+                raise AssertionError(f'{name}: {idx} (of type `{type(idx)}`)')
+        return bound_args
+
+    def substitute(self, spec: dict[Expr, Expr]) -> Expr:
+        """
+        Substitution of FunctionCall arguments could cause the return value to become more specific, in the case
+        where a variable is replaced with a specific value.
+        """
+        res = super().substitute(spec)
+        assert res is self
+        self.return_type = self.fn.call_return_type(self.bound_args)
+        self.col_type = self.return_type
+        return self
+
     def update(self, data_row: DataRow) -> None:
         """
         Update agg state
@@ -289,7 +321,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters_by_pos[idx].kind
-                in {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
+                in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
                 and not parameters_by_pos[idx].col_type.nullable
             ):
                 return None
@@ -302,7 +334,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters[param_name].kind
-                in {inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
+                in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
                 and not parameters[param_name].col_type.nullable
             ):
                 return None

pixeltable/exprs/globals.py

@@ -87,3 +87,15 @@ class ArithmeticOperator(enum.Enum):
         if self == self.FLOORDIV:
             return '//'
         raise AssertionError()
+
+
+class StringOperator(enum.Enum):
+    CONCAT = 0
+    REPEAT = 1
+
+    def __str__(self) -> str:
+        if self == self.CONCAT:
+            return '+'
+        if self == self.REPEAT:
+            return '*'
+        raise AssertionError()

pixeltable/exprs/json_mapper.py

@@ -20,16 +20,84 @@ class JsonMapper(Expr):
     JsonMapper transforms the list output of a JsonPath by applying a target expr to every element of the list.
     The target expr would typically contain relative JsonPaths, which are bound to an ObjectRef, which in turn
     is populated by JsonMapper.eval(). The JsonMapper effectively creates a new scope for its target expr.
+
+    JsonMapper is executed in two phases:
+    - the first phase is handled by Expr subclass JsonMapperDispatch, which constructs one nested DataRow per source
+      list element and evaluates the target expr within that (the nested DataRows are stored as a NestedRowList in the
+      slot of JsonMapperDispatch)
+    - JsonMapper.eval() collects the slot values of the target expr into its result list
     """
 
     target_expr_scope: ExprScope
     parent_mapper: Optional[JsonMapper]
     target_expr_eval_ctx: Optional[RowBuilder.EvalCtx]
 
-    def __init__(self, src_expr: Expr, target_expr: Expr):
+    def __init__(self, src_expr: Optional[Expr], target_expr: Optional[Expr]):
         # TODO: type spec should be list[target_expr.col_type]
         super().__init__(ts.JsonType())
 
+        dispatch = JsonMapperDispatch(src_expr, target_expr)
+        self.components.append(dispatch)
+        self.id = self._create_id()
+
+    def __repr__(self) -> str:
+        return f'map({self._src_expr}, lambda R: {self._target_expr})'
+
+    @property
+    def _src_expr(self) -> Expr:
+        return self.components[0].src_expr
+
+    @property
+    def _target_expr(self) -> Expr:
+        return self.components[0].target_expr
+
+    def _equals(self, _: JsonMapper) -> bool:
+        return True
+
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+        return None
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        from ..exec.expr_eval.evaluators import NestedRowList
+
+        dispatch_slot_idx = self.components[0].slot_idx
+        nested_rows = data_row.vals[dispatch_slot_idx]
+        if nested_rows is None:
+            data_row[self.slot_idx] = None
+            return
+        assert isinstance(nested_rows, NestedRowList)
+        # TODO: get the materialized slot idx, instead of relying on the fact that the target_expr is always at the end
+        data_row[self.slot_idx] = [row.vals[-1] for row in nested_rows.rows]
+
+    def _as_dict(self) -> dict:
+        """
+        We only serialize src and target exprs, everything else is re-created at runtime.
+        """
+        return {'components': [self._src_expr.as_dict(), self._target_expr.as_dict()]}
+
+    @classmethod
+    def _from_dict(cls, d: dict, components: list[Expr]) -> JsonMapper:
+        assert len(components) == 2
+        src_expr, target_expr = components[0], components[1]
+        return cls(src_expr, target_expr)
+
+
+class JsonMapperDispatch(Expr):
+    """
+    An operational Expr (ie, it doesn't represent any syntactic element) that is used by JsonMapper to materialize
+    its input DataRows. It has the same dependencies as the originating JsonMapper.
+
+    - The execution (= row dispatch) is handled by an expr_eval.Evaluator (JsonMapperDispatcher).
+    - It stores a NestedRowList instance in its slot.
+    """
+
+    target_expr_scope: ExprScope
+    parent_mapper: Optional[JsonMapperDispatch]
+    target_expr_eval_ctx: Optional[RowBuilder.EvalCtx]
+
+    def __init__(self, src_expr: Expr, target_expr: Expr):
+        super().__init__(ts.InvalidType())
+
         # we're creating a new scope, but we don't know yet whether this is nested within another JsonMapper;
         # this gets resolved in bind_rel_paths(); for now we assume we're in the global scope
         self.target_expr_scope = ExprScope(_GLOBAL_SCOPE)
@@ -40,28 +108,36 @@ class JsonMapper(Expr):
         self.parent_mapper = None
         self.target_expr_eval_ctx = None
 
-        # Intentionally create the id now, before adding the scope anchor; this ensures that JsonMappers will
-        # be recognized as equal so long as they have the same src_expr and target_expr.
+        # Intentionally create the id now, before adding the scope anchor; this ensures that JsonMapperDispatch
+        # instances will be recognized as equal so long as they have the same src_expr and target_expr.
         # TODO: Might this cause problems after certain substitutions?
         self.id = self._create_id()
 
         scope_anchor = ObjectRef(self.target_expr_scope, self)
         self.components.append(scope_anchor)
 
-    def _bind_rel_paths(self, mapper: Optional[JsonMapper] = None) -> None:
-        self._src_expr._bind_rel_paths(mapper)
-        self._target_expr._bind_rel_paths(self)
+    def _bind_rel_paths(self, mapper: Optional[JsonMapperDispatch] = None) -> None:
+        self.src_expr._bind_rel_paths(mapper)
+        self.target_expr._bind_rel_paths(self)
         self.parent_mapper = mapper
         parent_scope = _GLOBAL_SCOPE if mapper is None else mapper.target_expr_scope
         self.target_expr_scope.parent = parent_scope
 
+    def equals(self, other: Expr) -> bool:
+        """
+        We override equals() because we need to avoid comparing our scope anchor.
+        """
+        if type(self) is not type(other):
+            return False
+        return self.src_expr.equals(other.src_expr) and self.target_expr.equals(other.target_expr)
+
     def scope(self) -> ExprScope:
         # need to ignore target_expr
-        return self._src_expr.scope()
+        return self.src_expr.scope()
 
     def dependencies(self) -> list[Expr]:
-        result = [self._src_expr]
-        result.extend(self._target_dependencies(self._target_expr))
+        result = [self.src_expr]
+        result.extend(self._target_dependencies(self.target_expr))
         return result
 
     def _target_dependencies(self, e: Expr) -> list[Expr]:
@@ -77,23 +153,12 @@ class JsonMapper(Expr):
             result.extend(self._target_dependencies(c))
         return result
 
-    def equals(self, other: Expr) -> bool:
-        """
-        We override equals() because we need to avoid comparing our scope anchor.
-        """
-        if type(self) is not type(other):
-            return False
-        return self._src_expr.equals(other._src_expr) and self._target_expr.equals(other._target_expr)
-
-    def __repr__(self) -> str:
-        return f'{self._src_expr} >> {self._target_expr}'
-
     @property
-    def _src_expr(self) -> Expr:
+    def src_expr(self) -> Expr:
         return self.components[0]
 
     @property
-    def _target_expr(self) -> Expr:
+    def target_expr(self) -> Expr:
         return self.components[1]
 
     @property
@@ -104,37 +169,19 @@ class JsonMapper(Expr):
         assert isinstance(result, ObjectRef)
         return result
 
-    def _equals(self, _: JsonMapper) -> bool:
-        return True
-
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
-        return None
+    def __repr__(self) -> str:
+        return 'JsonMapperDispatch()'
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
-        # this will be called, but the value has already been materialized elsewhere
-        src = data_row[self._src_expr.slot_idx]
-        if not isinstance(src, list):
-            # invalid/non-list src path
-            data_row[self.slot_idx] = None
-            return
-
-        result = [None] * len(src)
-        if self.target_expr_eval_ctx is None:
-            self.target_expr_eval_ctx = row_builder.create_eval_ctx([self._target_expr])
-        for i, val in enumerate(src):
-            data_row[self.scope_anchor.slot_idx] = val
-            # stored target_expr
-            row_builder.eval(data_row, self.target_expr_eval_ctx, force_eval=self._target_expr.scope())
-            result[i] = data_row[self._target_expr.slot_idx]
-        data_row[self.slot_idx] = result
+        # eval is handled by JsonMapperDispatcher
+        raise AssertionError('this should never be called')
 
     def _as_dict(self) -> dict:
         """
-        We need to avoid serializing component[2], which is an ObjectRef.
+        JsonMapperDispatch instances are only created by the JsonMapper c'tor and never need to be serialized.
         """
-        return {'components': [c.as_dict() for c in self.components[0:2]]}
+        raise AssertionError('this should never be called')
 
     @classmethod
-    def _from_dict(cls, d: dict, components: list[Expr]) -> JsonMapper:
-        assert len(components) == 2
-        return cls(components[0], components[1])
+    def _from_dict(cls, d: dict, components: list[Expr]) -> JsonMapperDispatch:
+        raise AssertionError('this should never be called')

pixeltable/exprs/json_path.py

@@ -11,7 +11,7 @@ from pixeltable import catalog, exceptions as excs, type_system as ts
 from .data_row import DataRow
 from .expr import Expr
 from .globals import print_slice
-from .json_mapper import JsonMapper
+from .json_mapper import JsonMapperDispatch
 from .object_ref import ObjectRef
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
@@ -80,11 +80,10 @@ class JsonPath(Expr):
     def is_relative_path(self) -> bool:
         return self._anchor is None
 
-    @property
     def _has_relative_path(self) -> bool:
-        return self.is_relative_path() or super()._has_relative_path
+        return self.is_relative_path() or super()._has_relative_path()
 
-    def _bind_rel_paths(self, mapper: Optional['JsonMapper'] = None) -> None:
+    def _bind_rel_paths(self, mapper: Optional['JsonMapperDispatch'] = None) -> None:
         if self.is_relative_path():
             # TODO: take scope_idx into account
             self.set_anchor(mapper.scope_anchor)
@@ -110,12 +109,6 @@ class JsonPath(Expr):
             return JsonPath(self._anchor, [*self.path_elements, index])
         raise excs.Error(f'Invalid json list index: {index}')
 
-    def __rshift__(self, other: object) -> 'JsonMapper':
-        rhs_expr = Expr.from_object(other)
-        if rhs_expr is None:
-            raise excs.Error(f'>> requires an expression on the right-hand side, found {type(other)}')
-        return JsonMapper(self, rhs_expr)
-
     def default_column_name(self) -> Optional[str]:
         anchor_name = self._anchor.default_column_name() if self._anchor is not None else ''
         ret_name = f'{anchor_name}.{self._json_path()}'

pixeltable/exprs/method_ref.py

@@ -23,7 +23,7 @@ class MethodRef(Expr):
     # 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):
+    def __init__(self, base_expr: Expr, method_name: str) -> None:
         super().__init__(ts.InvalidType())  # The `MethodRef` is untyped until it is called.
         self.base_expr = base_expr
         self.method_name = method_name
@@ -43,7 +43,7 @@ class MethodRef(Expr):
         assert len(components) == 1
         return cls(components[0], d['method_name'])
 
-    def __call__(self, *args, **kwargs) -> FunctionCall:
+    def __call__(self, *args: Any, **kwargs: Any) -> FunctionCall:
         result = self.fn(*[self.base_expr, *args], **kwargs)
         assert isinstance(result, FunctionCall)
         result.is_method_call = True

pixeltable/exprs/object_ref.py

@@ -8,7 +8,7 @@ import pixeltable.type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr, ExprScope
-from .json_mapper import JsonMapper
+from .json_mapper import JsonMapperDispatch
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
@@ -19,7 +19,7 @@ class ObjectRef(Expr):
     The object is generated/materialized elsewhere and establishes a new scope.
     """
 
-    def __init__(self, scope: ExprScope, owner: JsonMapper):
+    def __init__(self, scope: ExprScope, owner: JsonMapperDispatch):
         # TODO: do we need an Unknown type after all?
         super().__init__(ts.JsonType())  # JsonType: this could be anything
         self._scope = scope

pixeltable/exprs/row_builder.py

@@ -77,6 +77,8 @@ class RowBuilder:
     transitive_dependents: np.ndarray  # of bool
     # dependencies[i] = direct dependencies of expr with slot idx i; transpose of dependents
     dependencies: np.ndarray  # of bool
+    # num_dependencies[i] = number of direct dependencies of expr with slot idx i
+    num_dependencies: np.ndarray  # of int
 
     # records the output_expr that a subexpr belongs to
     # (a subexpr can be shared across multiple output exprs)
@@ -209,6 +211,7 @@ class RowBuilder:
                 exc_dependencies[expr.slot_idx].add(d.slot_idx)
                 exc_dependencies[expr.slot_idx].update(exc_dependencies[d.slot_idx])
 
+        self.num_dependencies = np.sum(self.dependencies, axis=1)
         self.dependents = self.dependencies.T
         self.transitive_dependents = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
         for i in reversed(range(self.num_materialized)):
@@ -275,8 +278,14 @@ class RowBuilder:
         for d in e.dependencies():
             self._record_output_expr_id(d, output_expr_id)
 
-    def _compute_dependencies(self, target_slot_idxs: list[int], excluded_slot_idxs: list[int]) -> list[int]:
-        """Compute exprs needed to materialize the given target slots, excluding 'excluded_slot_idxs'"""
+    def _compute_dependencies(
+        self, target_slot_idxs: list[int], excluded_slot_idxs: list[int], target_scope: Optional[ExprScope] = None
+    ) -> list[int]:
+        """Compute exprs needed to materialize the given target slots, excluding 'excluded_slot_idxs'
+
+        If target_scope != None, stops transitive dependency resolution when leaving target_scope (ie, includes
+        immediate dependents that aren't in target_scope, but doesn't resolve those).
+        """
         dependencies: list[set[int]] = [set() for _ in range(self.num_materialized)]  # indexed by slot_idx
         # doing this front-to-back ensures that we capture transitive dependencies
         max_target_slot_idx = max(target_slot_idxs)
@@ -289,6 +298,9 @@ class RowBuilder:
             if expr.slot_idx in self.input_expr_slot_idxs:
                 # this is input and therefore doesn't depend on other exprs
                 continue
+            if target_scope is not None and expr.scope() != target_scope:
+                # don't resolve dependencies outside of target_scope
+                continue
             for d in expr.dependencies():
                 assert d.slot_idx is not None, f'{expr}, {d}'
                 if d.slot_idx in excluded_slot_idxs:
@@ -320,10 +332,15 @@ class RowBuilder:
         for c in e.components:
             self.__set_slot_idxs_aux(c)
 
-    def get_dependencies(self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None) -> list[Expr]:
+    def get_dependencies(
+        self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None, limit_scope: bool = True
+    ) -> list[Expr]:
         """
         Return list of dependencies needed to evaluate the given target exprs (expressed as slot idxs).
         The exprs given in 'exclude' are excluded.
+        If limit_scope == True, only returns dependencies in the same scope and immediate (ie, not transitive)
+        dependencies from enclosing scopes.
+
         Returns:
             list of Exprs from unique_exprs (= with slot_idx set)
         """
@@ -334,23 +351,33 @@ class RowBuilder:
             return []
         # make sure we only refer to recorded exprs
         targets = [self.unique_exprs[e] for e in targets]
+        target_scope: Optional[ExprScope] = None
+        if limit_scope:
+            # make sure all targets are from the same scope
+            target_scopes = {e.scope() for e in targets}
+            assert len(target_scopes) == 1
+            target_scope = target_scopes.pop()
         exclude = [self.unique_exprs[e] for e in exclude]
         target_slot_idxs = [e.slot_idx for e in targets]
         excluded_slot_idxs = [e.slot_idx for e in exclude]
-        all_dependencies = set(self._compute_dependencies(target_slot_idxs, excluded_slot_idxs))
+        all_dependencies = set(
+            self._compute_dependencies(target_slot_idxs, excluded_slot_idxs, target_scope=target_scope)
+        )
         all_dependencies.update(target_slot_idxs)
         result_ids = list(all_dependencies)
         result_ids.sort()
         return [self.unique_exprs[id] for id in result_ids]
 
-    def create_eval_ctx(self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None) -> EvalCtx:
+    def create_eval_ctx(
+        self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None, limit_scope: bool = True
+    ) -> EvalCtx:
         """Return EvalCtx for targets"""
         targets = list(targets)
         if exclude is None:
             exclude = []
         if len(targets) == 0:
             return self.EvalCtx([], [], [], [])
-        dependencies = self.get_dependencies(targets, exclude)
+        dependencies = self.get_dependencies(targets, exclude, limit_scope=limit_scope)
         targets = [self.unique_exprs[e] for e in targets]
         target_slot_idxs = [e.slot_idx for e in targets]
         ctx_slot_idxs = [e.slot_idx for e in dependencies]

pixeltable/exprs/similarity_expr.py

@@ -23,26 +23,12 @@ class SimilarityExpr(Expr):
 
         self.components = [col_ref, item_expr]
 
-        # determine index to use
-        idx_info = col_ref.col.get_idx_info()
         from pixeltable import index
 
-        embedding_idx_info = {
-            info.name: info for info in idx_info.values() if isinstance(info.idx, index.EmbeddingIndex)
-        }
-        if len(embedding_idx_info) == 0:
-            raise excs.Error(f'No index found for column {col_ref.col!r}')
-        if idx_name is not None and idx_name not in embedding_idx_info:
-            raise excs.Error(f'Index {idx_name!r} not found for column {col_ref.col.name!r}')
-        if len(embedding_idx_info) > 1:
-            if idx_name is None:
-                raise excs.Error(
-                    f'Column {col_ref.col.name!r} has multiple indices; use the index name to disambiguate: '
-                    f'`{col_ref.col.name}.similarity(..., idx=<name>)`'
-                )
-            self.idx_info = embedding_idx_info[idx_name]
-        else:
-            self.idx_info = next(iter(embedding_idx_info.values()))
+        # determine index to use
+        idx_dict = ColumnRef.find_embedding_index(col_ref.col, idx_name, 'similarity')
+        assert len(idx_dict) == 1
+        self.idx_info = next(iter(idx_dict.values()))
         idx = self.idx_info.idx
         assert isinstance(idx, index.EmbeddingIndex)
 
@@ -61,7 +47,7 @@ class SimilarityExpr(Expr):
     def __repr__(self) -> str:
         return f'{self.components[0]}.similarity({self.components[1]})'
 
-    def _id_attrs(self):
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('idx_name', self.idx_info.name)]
 
     def default_column_name(self) -> str:
@@ -86,8 +72,7 @@ class SimilarityExpr(Expr):
         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
-        raise AssertionError()
+        raise excs.Error('similarity(): cannot be used in a computed column')
 
     def _as_dict(self) -> dict:
         return {'idx_name': self.idx_info.name, **super()._as_dict()}

pixeltable/exprs/sql_element_cache.py

@@ -17,7 +17,7 @@ class SqlElementCache:
             for e, el in elements.items():
                 self.cache[e.id] = el
 
-    def extend(self, elements: ExprDict[sql.ColumnElement]):
+    def extend(self, elements: ExprDict[sql.ColumnElement]) -> None:
         for e, el in elements.items():
             self.cache[e.id] = el
 

pixeltable/exprs/string_op.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import Any, Optional, Union
+
+import sqlalchemy as sql
+
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
+
+from .data_row import DataRow
+from .expr import Expr
+from .globals import StringOperator
+from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
+
+
+class StringOp(Expr):
+    """
+    Allows operations on strings
+    """
+
+    operator: StringOperator
+
+    def __init__(self, operator: StringOperator, op1: Expr, op2: Expr):
+        super().__init__(ts.StringType(nullable=op1.col_type.nullable))
+        self.operator = operator
+        self.components = [op1, op2]
+        assert op1.col_type.is_string_type()
+        if operator in (StringOperator.CONCAT, StringOperator.REPEAT):
+            if operator == StringOperator.CONCAT and not op2.col_type.is_string_type():
+                raise excs.Error(
+                    f'{self}: {operator} on strings requires string type, but {op2} has type {op2.col_type}'
+                )
+            if operator == StringOperator.REPEAT and not op2.col_type.is_int_type():
+                raise excs.Error(f'{self}: {operator} on strings requires int type, but {op2} has type {op2.col_type}')
+        else:
+            raise excs.Error(
+                f'{self}: invalid operation {operator} on strings; '
+                f'only operators {StringOperator.CONCAT} and {StringOperator.REPEAT} are supported'
+            )
+        self.id = self._create_id()
+
+    @property
+    def _op1(self) -> Expr:
+        return self.components[0]
+
+    @property
+    def _op2(self) -> Expr:
+        return self.components[1]
+
+    def __repr__(self) -> str:
+        # add parentheses around operands that are StringOpExpr to express precedence
+        op1_str = f'({self._op1})' if isinstance(self._op1, StringOp) else str(self._op1)
+        op2_str = f'({self._op2})' if isinstance(self._op2, StringOp) else str(self._op2)
+        return f'{op1_str} {self.operator} {op2_str}'
+
+    def _equals(self, other: StringOp) -> bool:
+        return self.operator == other.operator
+
+    def _id_attrs(self) -> list[tuple[str, Any]]:
+        return [*super()._id_attrs(), ('operator', self.operator.value)]
+
+    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+        left = sql_elements.get(self._op1)
+        right = sql_elements.get(self._op2)
+        if left is None or right is None:
+            return None
+        if self.operator == StringOperator.CONCAT:
+            return left.concat(right)
+        if self.operator == StringOperator.REPEAT:
+            return sql.func.repeat(sql.cast(left, sql.String), sql.cast(right, sql.Integer))
+        return None
+
+    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]
+        data_row[self.slot_idx] = self.eval_nullable(op1_val, op2_val)
+
+    def eval_nullable(self, op1_val: Union[str, None], op2_val: Union[int, str, None]) -> Union[str, None]:
+        """
+        Return the result of evaluating the expression on two nullable int/float operands,
+        None is interpreted as SQL NULL
+        """
+        if op1_val is None or op2_val is None:
+            return None
+        return self.eval_non_null(op1_val, op2_val)
+
+    def eval_non_null(self, op1_val: str, op2_val: Union[int, str]) -> str:
+        """
+        Return the result of evaluating the expression on two int/float operands
+        """
+        assert self.operator in (StringOperator.CONCAT, StringOperator.REPEAT)
+        if self.operator == StringOperator.CONCAT:
+            assert isinstance(op2_val, str)
+            return op1_val + op2_val
+        else:
+            assert isinstance(op2_val, int)
+            return op1_val * op2_val
+
+    def _as_dict(self) -> dict:
+        return {'operator': self.operator.value, **super()._as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: dict, components: list[Expr]) -> StringOp:
+        assert 'operator' in d
+        assert len(components) == 2
+        return cls(StringOperator(d['operator']), components[0], components[1])

pixeltable/ext/__init__.py

@@ -13,5 +13,5 @@ from . import functions
 __all__ = local_public_names(__name__)
 
 
-def __dir__():
+def __dir__() -> list[str]:
     return __all__

pixeltable/ext/functions/__init__.py

@@ -7,5 +7,5 @@ from . import whisperx, yolox
 __all__ = local_public_names(__name__)
 
 
-def __dir__():
+def __dir__() -> list[str]:
     return __all__

pixeltable/ext/functions/whisperx.py

@@ -73,5 +73,5 @@ _model_cache: dict[tuple[str, str, str], 'FasterWhisperPipeline'] = {}
 __all__ = local_public_names(__name__)
 
 
-def __dir__():
+def __dir__() -> list[str]:
     return __all__