pixeltable 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

pixeltable/exprs/inline_array.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+from typing import Optional, List, Any, Dict, Tuple
+import copy
+
+import sqlalchemy as sql
+import numpy as np
+
+from .expr import Expr
+from .data_row import DataRow
+from .inline_dict import InlineDict
+from .row_builder import RowBuilder
+import pixeltable.catalog as catalog
+import pixeltable.type_system as ts
+
+
+class InlineArray(Expr):
+    """
+    Array 'literal' which can use Exprs as values.
+
+    The literal can be cast as either a pixeltable `ArrayType` or `JsonType`. If `force_json`
+    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.
+    """
+    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()))
+
+        # elements contains
+        # - for Expr elements: (index into components, None)
+        # - for non-Expr elements: (-1, value)
+        self.elements: List[Tuple[int, Any]] = []
+        for el in elements:
+            el = copy.deepcopy(el)
+            if isinstance(el, list):
+                # If col_type is an ArrayType, we'll require it to be a multidimensional array
+                # of the specified underlying type
+                el = InlineArray(tuple(el), force_json)
+            if isinstance(el, dict):
+                el = InlineDict(el)
+            if isinstance(el, Expr):
+                self.elements.append((len(self.components), None))
+                self.components.append(el)
+            else:
+                self.elements.append((-1, el))
+
+        inferred_element_type = ts.InvalidType()
+        for idx, val in self.elements:
+            if idx >= 0:
+                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
+
+        if force_json or inferred_element_type is None:
+            # JSON conversion is forced, or there is no common supertype
+            # TODO: make sure this doesn't contain Images
+            self.col_type = ts.JsonType()
+        elif inferred_element_type.is_scalar_type():
+            self.col_type = ts.ArrayType((len(self.elements),), inferred_element_type)
+        elif inferred_element_type.is_array_type():
+            assert isinstance(inferred_element_type, ts.ArrayType)
+            self.col_type = ts.ArrayType(
+                (len(self.elements), *inferred_element_type.shape), ts.ColumnType.make_type(inferred_element_type.dtype))
+        else:
+            self.col_type = ts.JsonType()
+
+        self.id = self._create_id()
+
+    def __str__(self) -> str:
+        elem_strs = [str(val) if val is not None else str(self.components[idx]) for idx, val in self.elements]
+        return f'[{", ".join(elem_strs)}]'
+
+    def _equals(self, other: InlineDict) -> bool:
+        return self.elements == other.elements
+
+    def _id_attrs(self) -> List[Tuple[str, Any]]:
+        return super()._id_attrs() + [('elements', self.elements)]
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        return None
+
+    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:
+                result[i] = data_row[self.components[child_idx].slot_idx]
+            else:
+                result[i] = copy.deepcopy(val)
+        if self.col_type.is_array_type():
+            data_row[self.slot_idx] = np.array(result)
+        else:
+            data_row[self.slot_idx] = result
+
+    def _as_dict(self) -> Dict:
+        return {'elements': self.elements, **super()._as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+        assert 'elements' in d
+        arg: List[Any] = []
+        for idx, val in d['elements']:
+            if idx >= 0:
+                arg.append(components[idx])
+            else:
+                arg.append(val)
+        return cls(tuple(arg))

pixeltable/exprs/inline_dict.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+from typing import Optional, List, Any, Dict, Tuple
+import copy
+
+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
+
+
+class InlineDict(Expr):
+    """
+    Dictionary 'literal' which can use Exprs as values.
+    """
+    def __init__(self, d: Dict):
+        from .inline_array import InlineArray
+        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 key, val in d.items():
+            if not isinstance(key, str):
+                raise excs.Error(f'Dictionary requires string keys, {key} has type {type(key)}')
+            val = copy.deepcopy(val)
+            if isinstance(val, dict):
+                val = InlineDict(val)
+            if isinstance(val, list) or isinstance(val, tuple):
+                val = InlineArray(tuple(val), force_json=True)
+            if isinstance(val, Expr):
+                self.dict_items.append((key, len(self.components), None))
+                self.components.append(val)
+            else:
+                self.dict_items.append((key, -1, val))
+
+        self.type_spec: Optional[Dict[str, ts.ColumnType]] = {}
+        for key, idx, _ in self.dict_items:
+            if idx == -1:
+                # TODO: implement type inference for values
+                self.type_spec = None
+                break
+            self.type_spec[key] = self.components[idx].col_type
+        self.col_type = ts.JsonType(self.type_spec)
+
+        self.id = self._create_id()
+
+    def __str__(self) -> str:
+        item_strs: List[str] = []
+        i = 0
+        def print_val(val: Any) -> str:
+            if isinstance(val, str):
+                return f"'{val}'"
+            return str(val)
+        for key, idx, val in self.dict_items:
+            if idx != -1:
+                item_strs.append(f"'{key}': {str(self.components[i])}")
+                i += 1
+            else:
+                item_strs.append(f"'{key}': {print_val(val)}")
+        return '{' + ', '.join(item_strs) + '}'
+
+    def _equals(self, other: InlineDict) -> bool:
+        return self.dict_items == other.dict_items
+
+    def _id_attrs(self) -> List[Tuple[str, Any]]:
+        return super()._id_attrs() + [('dict_items', self.dict_items)]
+
+    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}
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        return None
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        result = {}
+        for key, idx, val in self.dict_items:
+            assert isinstance(key, str)
+            if idx >= 0:
+                result[key] = data_row[self.components[idx].slot_idx]
+            else:
+                result[key] = copy.deepcopy(val)
+        data_row[self.slot_idx] = result
+
+    def _as_dict(self) -> Dict:
+        return {'dict_items': self.dict_items, **super()._as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+        assert 'dict_items' in d
+        arg: Dict[str, Any] = {}
+        for key, idx, val in d['dict_items']:
+            if idx >= 0:
+                arg[key] = components[idx]
+            else:
+                arg[key] = val
+        return cls(arg)

pixeltable/exprs/is_null.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from typing import Optional, List, Dict
+
+import sqlalchemy as sql
+
+from .predicate import Predicate
+from .expr import Expr
+from .data_row import DataRow
+from .row_builder import RowBuilder
+import pixeltable.catalog as catalog
+
+
+class IsNull(Predicate):
+    def __init__(self, e: Expr):
+        super().__init__()
+        self.components = [e]
+        self.id = self._create_id()
+
+    def __str__(self) -> str:
+        return f'{str(self.components[0])} == None'
+
+    def _equals(self, other: IsNull) -> bool:
+        return True
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        e = self.components[0].sql_expr()
+        if e is None:
+            return None
+        return e == None
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        data_row[self.slot_idx] = data_row[self.components[0].slot_idx] is None
+
+    @classmethod
+    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+        assert len(components) == 1
+        return cls(components[0])
+

pixeltable/exprs/json_mapper.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+from typing import Optional, List, Dict
+
+import sqlalchemy as sql
+
+from .expr import Expr, ExprScope, _GLOBAL_SCOPE
+from .data_row import DataRow
+from .row_builder import RowBuilder
+import pixeltable.catalog as catalog
+import pixeltable.type_system as ts
+
+
+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.
+    """
+    def __init__(self, src_expr: Expr, target_expr: Expr):
+        # TODO: type spec should be List[target_expr.col_type]
+        super().__init__(ts.JsonType())
+
+        # 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)
+
+        from .object_ref import ObjectRef
+        scope_anchor = ObjectRef(self.target_expr_scope, self)
+        self.components = [src_expr, target_expr, scope_anchor]
+        self.parent_mapper: Optional[JsonMapper] = None
+        self.target_expr_eval_ctx: Optional[RowBuilder.EvalCtx] = None
+        self.id = self._create_id()
+
+    def bind_rel_paths(self, mapper: Optional[JsonMapper]) -> 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 scope(self) -> ExprScope:
+        # need to ignore target_expr
+        return self._src_expr.scope()
+
+    def dependencies(self) -> List[Expr]:
+        result = [self._src_expr]
+        result.extend(self._target_dependencies(self._target_expr))
+        return result
+
+    def _target_dependencies(self, e: Expr) -> List[Expr]:
+        """
+        Return all subexprs of e of which the scope isn't contained in target_expr_scope.
+        Those need to be evaluated before us.
+        """
+        expr_scope = e.scope()
+        if not expr_scope.is_contained_in(self.target_expr_scope):
+            return [e]
+        result: List[Expr] = []
+        for c in e.components:
+            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) != type(other):
+            return False
+        return self._src_expr.equals(other._src_expr) and self._target_expr.equals(other._target_expr)
+
+    def __str__(self) -> str:
+        return f'{str(self._src_expr)} >> {str(self._target_expr)}'
+
+    @property
+    def _src_expr(self) -> Expr:
+        return self.components[0]
+
+    @property
+    def _target_expr(self) -> Expr:
+        return self.components[1]
+
+    @property
+    def scope_anchor(self) -> Expr:
+        return self.components[2]
+
+    def _equals(self, other: JsonMapper) -> bool:
+        return True
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        return None
+
+    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
+            exc_tb = row_builder.eval(data_row, self.target_expr_eval_ctx)
+            assert exc_tb is None
+            result[i] = data_row[self._target_expr.slot_idx]
+        data_row[self.slot_idx] = result
+
+    def _as_dict(self) -> Dict:
+        """
+        We need to avoid serializing component[2], which is an ObjectRef.
+        """
+        return {'components': [c.as_dict() for c in self.components[0:2]]}
+
+    @classmethod
+    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+        assert len(components) == 2
+        return cls(components[0], components[1])
+

pixeltable/exprs/json_path.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+from typing import Optional, List, Any, Dict, Tuple, Union
+
+import jmespath
+import sqlalchemy as sql
+
+from .globals import print_slice
+from .expr import Expr
+from .json_mapper import JsonMapper
+from .data_row import DataRow
+from .row_builder import RowBuilder
+import pixeltable
+import pixeltable.exceptions as excs
+import pixeltable.catalog as catalog
+import pixeltable.type_system as ts
+
+
+class JsonPath(Expr):
+    def __init__(self, anchor: Optional['pixeltable.exprs.ColumnRef'], path_elements: Optional[List[str]] = None, scope_idx: int = 0):
+        """
+        anchor can be None, in which case this is a relative JsonPath and the anchor is set later via set_anchor().
+        scope_idx: for relative paths, index of referenced JsonMapper
+        (0: indicates the immediately preceding JsonMapper, -1: the parent of the immediately preceding mapper, ...)
+        """
+        if path_elements is None:
+            path_elements = []
+        super().__init__(ts.JsonType())
+        if anchor is not None:
+            self.components = [anchor]
+        self.path_elements: List[Union[str, int]] = path_elements
+        self.compiled_path = jmespath.compile(self._json_path()) if len(path_elements) > 0 else None
+        self.scope_idx = scope_idx
+        # NOTE: the _create_id() result will change if set_anchor() gets called;
+        # this is not a problem, because _create_id() shouldn't be called after init()
+        self.id = self._create_id()
+
+    def __str__(self) -> str:
+        # else "R": the anchor is RELATIVE_PATH_ROOT
+        return (f'{str(self._anchor) if self._anchor is not None else "R"}'
+            f'{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}')
+
+    def _as_dict(self) -> Dict:
+        return {'path_elements': self.path_elements, 'scope_idx': self.scope_idx, **super()._as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+        assert 'path_elements' in d
+        assert 'scope_idx' in d
+        assert len(components) <= 1
+        anchor = components[0] if len(components) == 1 else None
+        return cls(anchor, d['path_elements'], d['scope_idx'])
+
+    @property
+    def _anchor(self) -> Optional[Expr]:
+        return None if len(self.components) == 0 else self.components[0]
+
+    def set_anchor(self, anchor: Expr) -> None:
+        assert len(self.components) == 0
+        self.components = [anchor]
+
+    def is_relative_path(self) -> bool:
+        return self._anchor is None
+
+    def bind_rel_paths(self, mapper: Optional['JsonMapper'] = None) -> None:
+        if not self.is_relative_path():
+            return
+        # TODO: take scope_idx into account
+        self.set_anchor(mapper.scope_anchor)
+
+    def __call__(self, *args: object, **kwargs: object) -> 'JsonPath':
+        """
+        Construct a relative path that references an ancestor of the immediately enclosing JsonMapper.
+        """
+        if not self.is_relative_path():
+            raise excs.Error(f'() for an absolute path is invalid')
+        if len(args) != 1 or not isinstance(args[0], int) or args[0] >= 0:
+            raise excs.Error(f'R() requires a negative index')
+        return JsonPath(None, [], args[0])
+
+    def __getattr__(self, name: str) -> 'JsonPath':
+        assert isinstance(name, str)
+        return JsonPath(self._anchor, self.path_elements + [name])
+
+    def __getitem__(self, index: object) -> 'JsonPath':
+        if isinstance(index, str):
+            if index != '*':
+                raise excs.Error(f'Invalid json list index: {index}')
+        else:
+            if not isinstance(index, slice) and not isinstance(index, int):
+                raise excs.Error(f'Invalid json list index: {index}')
+        return JsonPath(self._anchor, self.path_elements + [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()}'
+        
+        def cleanup_char(s : str) -> str:
+            if s == '.':
+                return '_'
+            elif s == '*':
+                return 'star'
+            elif s.isalnum():
+                return s
+            else:
+                return ''
+            
+        clean_name = ''.join(map(cleanup_char, ret_name))
+        clean_name = clean_name.lstrip('_') # remove leading underscore
+        if clean_name == '':
+            clean_name = None
+        
+        assert clean_name is None or catalog.is_valid_identifier(clean_name)
+        return clean_name
+
+    def _equals(self, other: JsonPath) -> bool:
+        return self.path_elements == other.path_elements
+
+    def _id_attrs(self) -> List[Tuple[str, Any]]:
+        return super()._id_attrs() + [('path_elements', self.path_elements)]
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        """
+        Postgres appears to have a bug: jsonb_path_query('{a: [{b: 0}, {b: 1}]}', '$.a.b') returns
+        *two* rows (each containing col val 0), not a single row with [0, 0].
+        We need to use a workaround: retrieve the entire dict, then use jmespath to extract the path correctly.
+        """
+        #path_str = '$.' + '.'.join(self.path_elements)
+        #assert isinstance(self._anchor(), ColumnRef)
+        #return sql.func.jsonb_path_query(self._anchor().col.sa_col, path_str)
+        return None
+
+    def _json_path(self) -> str:
+        assert len(self.path_elements) > 0
+        result: List[str] = []
+        for element in self.path_elements:
+            if element == '*':
+                result.append('[*]')
+            elif isinstance(element, str):
+                result.append(f'{"." if len(result) > 0 else ""}{element}')
+            elif isinstance(element, int):
+                result.append(f'[{element}]')
+            elif isinstance(element, slice):
+                result.append(f'[{print_slice(element)}]')
+        return ''.join(result)
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        val = data_row[self._anchor.slot_idx]
+        if self.compiled_path is not None:
+            val = self.compiled_path.search(val)
+        data_row[self.slot_idx] = val
+
+
+RELATIVE_PATH_ROOT = JsonPath(None)

pixeltable/exprs/literal.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+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.catalog as catalog
+import pixeltable.type_system as ts
+
+class Literal(Expr):
+    def __init__(self, val: Any, col_type: Optional[ts.ColumnType] = None):
+        if col_type is not None:
+            val = col_type.create_literal(val)
+        else:
+            # try to determine a type for val
+            col_type = ts.ColumnType.infer_literal_type(val)
+            if col_type is None:
+                raise TypeError(f'Not a valid literal: {val}')
+        super().__init__(col_type)
+        self.val = val
+        self.id = self._create_id()
+
+    def default_column_name(self) -> Optional[str]:
+        return 'Literal'
+
+    def __str__(self) -> str:
+        if self.col_type.is_string_type() or self.col_type.is_timestamp_type():
+            return f"'{self.val}'"
+        return str(self.val)
+
+    def _equals(self, other: Literal) -> bool:
+        return self.val == other.val
+
+    def _id_attrs(self) -> List[Tuple[str, Any]]:
+        return super()._id_attrs() + [('val', self.val)]
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        # we need to return something here so that we can generate a Where clause for predicates
+        # that involve literals (like Where c > 0)
+        return sql.sql.expression.literal(self.val)
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        # this will be called, even though sql_expr() does not return None
+        data_row[self.slot_idx] = self.val
+
+    def _as_dict(self) -> Dict:
+        return {'val': self.val, **super()._as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+        assert 'val' in d
+        return cls(d['val'])

pixeltable/exprs/object_ref.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+from typing import Optional, List, Any, Dict, Tuple
+import copy
+
+import sqlalchemy as sql
+
+from .expr import Expr, ExprScope
+from .json_mapper import JsonMapper
+from .data_row import DataRow
+from .row_builder import RowBuilder
+import pixeltable.type_system as ts
+
+
+class ObjectRef(Expr):
+    """
+    Reference to an intermediate result, such as the "scope variable" produced by a JsonMapper.
+    The object is generated/materialized elsewhere and establishes a new scope.
+    """
+    def __init__(self, scope: ExprScope, owner: JsonMapper):
+        # TODO: do we need an Unknown type after all?
+        super().__init__(ts.JsonType())  # JsonType: this could be anything
+        self._scope = scope
+        self.owner = owner
+        self.id = self._create_id()
+
+    def scope(self) -> ExprScope:
+        return self._scope
+
+    def __str__(self) -> str:
+        assert False
+
+    def _equals(self, other: ObjectRef) -> bool:
+        return self.owner is other.owner
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        return None
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        # this will be called, but the value has already been materialized elsewhere
+        pass
+

pixeltable/exprs/predicate.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+from typing import Optional, List, Tuple, Callable
+
+from .expr import Expr
+from .globals import LogicalOperator
+import pixeltable
+import pixeltable.type_system as ts
+
+
+class Predicate(Expr):
+    def __init__(self) -> None:
+        super().__init__(ts.BoolType())
+
+    def split_conjuncts(
+            self, condition: Callable[[Predicate], bool]) -> Tuple[List[Predicate], Optional[Predicate]]:
+        """
+        Returns clauses of a conjunction that meet condition in the first element.
+        The second element contains remaining clauses, rolled into a conjunction.
+        """
+        if condition(self):
+            return [self], None
+        else:
+            return [], self
+
+    def __and__(self, other: object) -> 'pixeltable.exprs.CompoundPredicate':
+        if not isinstance(other, Expr):
+            raise TypeError(f'Other needs to be an expression: {type(other)}')
+        if not other.col_type.is_bool_type():
+            raise TypeError(f'Other needs to be an expression that returns a boolean: {other.col_type}')
+        from .compound_predicate import CompoundPredicate
+        return CompoundPredicate(LogicalOperator.AND, [self, other])
+
+    def __or__(self, other: object) -> 'pixeltable.exprs.CompoundPredicate':
+        if not isinstance(other, Expr):
+            raise TypeError(f'Other needs to be an expression: {type(other)}')
+        if not other.col_type.is_bool_type():
+            raise TypeError(f'Other needs to be an expression that returns a boolean: {other.col_type}')
+        from .compound_predicate import CompoundPredicate
+        return CompoundPredicate(LogicalOperator.OR, [self, other])
+
+    def __invert__(self) -> 'pixeltable.exprs.CompoundPredicate':
+        from .compound_predicate import CompoundPredicate
+        return CompoundPredicate(LogicalOperator.NOT, [self])
+