pixeltable 0.4.0rc3__py3-none-any.whl → 0.4.20__py3-none-any.whl

pixeltable/exprs/data_row.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+import dataclasses
 import datetime
 import io
 import urllib.parse
 import urllib.request
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import numpy as np
 import pgvector.sqlalchemy  # type: ignore[import-untyped]
@@ -13,14 +14,72 @@ import PIL
 import PIL.Image
 import sqlalchemy as sql
 
-from pixeltable import env
+import pixeltable.utils.image as image_utils
+from pixeltable import catalog, env
+from pixeltable.utils.local_store import TempStore
+from pixeltable.utils.misc import non_none_dict_factory
+
+
+@dataclasses.dataclass
+class ArrayMd:
+    """
+    Metadata for array cells that are stored externally.
+    """
+
+    start: int
+    end: int
+
+    # we store bool arrays as packed bits (uint8 arrays), and need to record the shape to reconstruct the array
+    is_bool: bool = False
+    shape: tuple[int, ...] | None = None
+
+    def as_dict(self) -> dict:
+        # dict_factory: suppress Nones
+        x = dataclasses.asdict(self, dict_factory=non_none_dict_factory)
+        return x
+
+
+@dataclasses.dataclass
+class CellMd:
+    """
+    Content of the cellmd column.
+
+    All fields are optional, to minimize storage.
+    """
+
+    errortype: str | None = None
+    errormsg: str | None = None
+
+    # a list of file urls that are used to store images and arrays; only set for json and array columns
+    # for json columns: a list of all urls referenced in the column value
+    # for array columns: a single url
+    file_urls: list[str] | None = None
+
+    array_md: ArrayMd | None = None
+
+    @classmethod
+    def from_dict(cls, d: dict) -> CellMd:
+        x: CellMd
+        if 'array_md' in d:
+            d2 = d.copy()
+            del d2['array_md']
+            x = cls(**d2, array_md=ArrayMd(**d['array_md']))
+        else:
+            x = cls(**d)
+        return x
+
+    def as_dict(self) -> dict:
+        x = dataclasses.asdict(self, dict_factory=non_none_dict_factory)
+        return x
 
 
 class DataRow:
     """
     Encapsulates all data and execution state needed by RowBuilder and DataRowBatch:
     - state for in-memory computation
-    - state for storing the data
+    - state needed for expression evaluation
+    - containers for output column values
+
     This is not meant to be a black-box abstraction.
 
     In-memory representations by column type:
@@ -38,37 +97,49 @@ class DataRow:
     - DocumentType: local path if available, otherwise url
     """
 
+    # expr evaluation state; indexed by slot idx
     vals: np.ndarray  # of object
     has_val: np.ndarray  # of bool
     excs: np.ndarray  # of object
-
-    # expr evaluation state; indexed by slot idx
     missing_slots: np.ndarray  # of bool; number of missing dependencies
     missing_dependents: np.ndarray  # of int16; number of missing dependents
     is_scheduled: np.ndarray  # of bool; True if this slot is scheduled for evaluation
 
-    # control structures that are shared across all DataRows in a batch
-    img_slot_idxs: list[int]
-    media_slot_idxs: list[int]
-    array_slot_idxs: list[int]
-
-    # the primary key of a store row is a sequence of ints (the number is different for table vs view)
-    pk: Optional[tuple[int, ...]]
+    # CellMd needed for query execution; needs to be indexed by slot idx, not column id, to work for joins
+    slot_md: dict[int, CellMd]
 
     # file_urls:
     # - stored url of file for media in vals[i]
     # - None if vals[i] is not media type
     # - not None if file_paths[i] is not None
+    # TODO: this is a sparse vector; should it be a dict[int, str]?
     file_urls: np.ndarray  # of str
 
     # file_paths:
     # - local path of media file in vals[i]; points to the file cache if file_urls[i] is remote
     # - None if vals[i] is not a media type or if there is no local file yet for file_urls[i]
+    # TODO: this is a sparse vector; should it be a dict[int, str]?
     file_paths: np.ndarray  # of str
 
+    # If `may_have_exc` is False, then we guarantee that no slot has an exception set. This is used to optimize
+    # exception handling under normal operation.
+    _may_have_exc: bool
+
+    # the primary key of a store row is a sequence of ints (the number is different for table vs view)
+    pk: tuple[int, ...] | None
     # for nested rows (ie, those produced by JsonMapperDispatcher)
-    parent_row: Optional[DataRow]
-    parent_slot_idx: Optional[int]
+    parent_row: DataRow | None
+    parent_slot_idx: int | None
+
+    # state for table output (insert()/update()); key: column id
+    cell_vals: dict[int, Any]  # materialized values of output columns, in the format required for the column
+    cell_md: dict[int, CellMd]
+
+    # control structures that are shared across all DataRows in a batch
+    img_slot_idxs: list[int]
+    media_slot_idxs: list[int]
+    array_slot_idxs: list[int]
+    json_slot_idxs: list[int]
 
     def __init__(
         self,
@@ -76,36 +147,42 @@ class DataRow:
         img_slot_idxs: list[int],
         media_slot_idxs: list[int],
         array_slot_idxs: list[int],
-        parent_row: Optional[DataRow] = None,
-        parent_slot_idx: Optional[int] = None,
+        json_slot_idxs: list[int],
+        parent_row: DataRow | None = None,
+        parent_slot_idx: int | None = None,
     ):
-        self.img_slot_idxs = img_slot_idxs
-        self.media_slot_idxs = media_slot_idxs
-        self.array_slot_idxs = array_slot_idxs
         self.init(size)
         self.parent_row = parent_row
         self.parent_slot_idx = parent_slot_idx
-
-    def init(self, num_slots: int) -> None:
-        self.vals = np.full(num_slots, None, dtype=object)
-        self.has_val = np.zeros(num_slots, dtype=bool)
-        self.excs = np.full(num_slots, None, dtype=object)
-        self.missing_slots = np.zeros(num_slots, dtype=bool)
-        self.missing_dependents = np.zeros(num_slots, dtype=np.int16)
-        self.is_scheduled = np.zeros(num_slots, dtype=bool)
+        self.img_slot_idxs = img_slot_idxs
+        self.media_slot_idxs = media_slot_idxs
+        self.array_slot_idxs = array_slot_idxs
+        self.json_slot_idxs = json_slot_idxs
+
+    def init(self, size: int) -> None:
+        self.vals = np.full(size, None, dtype=object)
+        self.has_val = np.zeros(size, dtype=bool)
+        self.excs = np.full(size, None, dtype=object)
+        self.missing_slots = np.zeros(size, dtype=bool)
+        self.missing_dependents = np.zeros(size, dtype=np.int16)
+        self.is_scheduled = np.zeros(size, dtype=bool)
+        self.slot_md = {}
+        self.file_urls = np.full(size, None, dtype=object)
+        self.file_paths = np.full(size, None, dtype=object)
+        self._may_have_exc = False
+        self.cell_vals = {}
+        self.cell_md = {}
         self.pk = None
-        self.file_urls = np.full(num_slots, None, dtype=object)
-        self.file_paths = np.full(num_slots, None, dtype=object)
         self.parent_row = None
         self.parent_slot_idx = None
 
-    def clear(self, idxs: Optional[np.ndarray] = None) -> None:
-        if idxs is not None:
-            self.has_val[idxs] = False
-            self.vals[idxs] = None
-            self.excs[idxs] = None
-            self.file_urls[idxs] = None
-            self.file_paths[idxs] = None
+    def clear(self, slot_idxs: np.ndarray | None = None) -> None:
+        if slot_idxs is not None:
+            self.has_val[slot_idxs] = False
+            self.vals[slot_idxs] = None
+            self.excs[slot_idxs] = None
+            self.file_urls[slot_idxs] = None
+            self.file_paths[slot_idxs] = None
         else:
             self.init(len(self.vals))
 
@@ -132,20 +209,23 @@ class DataRow:
     def set_pk(self, pk: tuple[int, ...]) -> None:
         self.pk = pk
 
-    def has_exc(self, slot_idx: Optional[int] = None) -> bool:
+    def has_exc(self, slot_idx: int | None = None) -> bool:
         """
         Returns True if an exception has been set for the given slot index, or for any slot index if slot_idx is None
         """
+        if not self._may_have_exc:
+            return False
+
         if slot_idx is not None:
             return self.excs[slot_idx] is not None
         return (self.excs != None).any()
 
-    def get_exc(self, slot_idx: int) -> Optional[Exception]:
+    def get_exc(self, slot_idx: int) -> Exception | None:
         exc = self.excs[slot_idx]
         assert exc is None or isinstance(exc, Exception)
         return exc
 
-    def get_first_exc(self) -> Optional[Exception]:
+    def get_first_exc(self) -> Exception | None:
         mask = self.excs != None
         if not mask.any():
             return None
@@ -154,6 +234,7 @@ class DataRow:
     def set_exc(self, slot_idx: int, exc: Exception) -> None:
         assert self.excs[slot_idx] is None
         self.excs[slot_idx] = exc
+        self._may_have_exc = True
 
         # an exception means the value is None
         self.has_val[slot_idx] = True
@@ -179,7 +260,7 @@ class DataRow:
 
         return self.vals[index]
 
-    def get_stored_val(self, index: int, sa_col_type: Optional[sql.types.TypeEngine] = None) -> Any:
+    def get_stored_val(self, index: int, sa_col_type: sql.types.TypeEngine | None = None) -> Any:
         """Return the value that gets stored in the db"""
         assert self.excs[index] is None
         if not self.has_val[index]:
@@ -247,30 +328,46 @@ class DataRow:
             self.vals[idx] = val
         self.has_val[idx] = True
 
-    def flush_img(self, index: int, filepath: Optional[str] = None) -> None:
-        """Discard the in-memory value and save it to a local file, if filepath is not None"""
+    def prepare_col_val_for_save(self, index: int, col: catalog.Column | None = None) -> bool:
+        """
+        Prepare to save a column's value into the appropriate store. Discard unneeded values.
+
+        Return:
+            True if the media object in the column needs to be saved.
+        """
         if self.vals[index] is None:
-            return
+            return False
+
+        if self.file_urls[index] is not None:
+            return False
+
         assert self.excs[index] is None
         if self.file_paths[index] is None:
-            if filepath is not None:
-                image = self.vals[index]
-                assert isinstance(image, PIL.Image.Image)
-                # Default to JPEG unless the image has a transparency layer (which isn't supported by JPEG).
-                # In that case, use WebP instead.
-                format = 'webp' if image.has_transparency_data else 'jpeg'
-                if not filepath.endswith(f'.{format}'):
-                    filepath += f'.{format}'
-                self.file_paths[index] = filepath
-                self.file_urls[index] = urllib.parse.urljoin('file:', urllib.request.pathname2url(filepath))
-                image.save(filepath, format=format)
+            if col is not None:
+                # This is a media object that needs to be saved
+                return True
             else:
-                # we discard the content of this cell
+                # This is a media object that we don't care about, so we discard it
                 self.has_val[index] = False
         else:
             # we already have a file for this image, nothing left to do
             pass
+
+        self.vals[index] = None
+        return False
+
+    def save_media_to_temp(self, index: int, col: catalog.Column) -> str:
+        """Save the media object in the column to the TempStore.
+        Objects cannot be saved directly to general destinations."""
+        assert col.col_type.is_media_type()
+        val = self.vals[index]
+        format = None
+        if isinstance(val, PIL.Image.Image):
+            format = image_utils.default_format(val)
+        filepath, url = TempStore.save_media_object(val, col, format=format)
+        self.file_paths[index] = str(filepath) if filepath is not None else None
         self.vals[index] = None
+        return url
 
     @property
     def rowid(self) -> tuple[int, ...]:

pixeltable/exprs/expr.py

@@ -7,7 +7,7 @@ import inspect
 import json
 import sys
 import typing
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, Optional, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, TypeVar, overload
 from uuid import UUID
 
 import numpy as np
@@ -29,7 +29,7 @@ class ExprScope:
     parent is None: outermost scope
     """
 
-    def __init__(self, parent: Optional[ExprScope]):
+    def __init__(self, parent: ExprScope | None):
         self.parent = parent
 
     def is_contained_in(self, other: ExprScope) -> bool:
@@ -61,13 +61,13 @@ class Expr(abc.ABC):
     # - set by the subclass's __init__()
     # - produced by _create_id()
     # - not expected to survive a serialize()/deserialize() roundtrip
-    id: Optional[int]
+    id: int | None
 
     # index of the expr's value in the data row:
     # - set for all materialized exprs
     # - None: not executable
     # - not set for subexprs that don't need to be materialized because the parent can be materialized via SQL
-    slot_idx: Optional[int]
+    slot_idx: int | None
 
     T = TypeVar('T', bound='Expr')
 
@@ -103,7 +103,7 @@ class Expr(abc.ABC):
         assert not has_rel_path, self._expr_tree()
         assert not self._has_relative_path(), self._expr_tree()
 
-    def _bind_rel_paths(self, mapper: Optional['exprs.JsonMapperDispatch'] = None) -> None:
+    def _bind_rel_paths(self, mapper: 'exprs.JsonMapperDispatch' | None = None) -> None:
         for c in self.components:
             c._bind_rel_paths(mapper)
 
@@ -118,7 +118,7 @@ class Expr(abc.ABC):
         for c in self.components:
             c._expr_tree_r(indent + 2, buf)
 
-    def default_column_name(self) -> Optional[str]:
+    def default_column_name(self) -> str | None:
         """
         Returns:
             None if this expression lacks a default name,
@@ -127,7 +127,7 @@ class Expr(abc.ABC):
         return None
 
     @property
-    def validation_error(self) -> Optional[str]:
+    def validation_error(self) -> str | None:
         """
         Subclasses can override this to indicate that validation has failed after a catalog load.
 
@@ -205,12 +205,12 @@ class Expr(abc.ABC):
         return result
 
     @classmethod
-    def copy_list(cls, expr_list: Optional[list[Expr]]) -> Optional[list[Expr]]:
+    def copy_list(cls, expr_list: list[Expr] | None) -> list[Expr] | None:
         if expr_list is None:
             return None
         return [e.copy() for e in expr_list]
 
-    def __deepcopy__(self, memo: Optional[dict[int, Any]] = None) -> Expr:
+    def __deepcopy__(self, memo: dict[int, Any] | None = None) -> Expr:
         # we don't need to create an actual deep copy because all state other than execution state is read-only
         if memo is None:
             memo = {}
@@ -241,7 +241,7 @@ class Expr(abc.ABC):
         for i in range(len(expr_list)):
             expr_list[i] = expr_list[i].substitute(spec)
 
-    def resolve_computed_cols(self, resolve_cols: Optional[set[catalog.Column]] = None) -> Expr:
+    def resolve_computed_cols(self, resolve_cols: set[catalog.Column] | None = None) -> Expr:
         """
         Recursively replace ColRefs to unstored computed columns with their value exprs.
         Also replaces references to stored computed columns in resolve_cols.
@@ -309,18 +309,18 @@ class Expr(abc.ABC):
 
     @overload
     def subexprs(
-        self, *, filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
+        self, *, filter: Callable[[Expr], bool] | None = None, traverse_matches: bool = True
     ) -> Iterator[Expr]: ...
 
     @overload
     def subexprs(
-        self, expr_class: type[T], filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
+        self, expr_class: type[T], filter: Callable[[Expr], bool] | None = None, traverse_matches: bool = True
     ) -> Iterator[T]: ...
 
     def subexprs(
         self,
-        expr_class: Optional[type[T]] = None,
-        filter: Optional[Callable[[Expr], bool]] = None,
+        expr_class: type[T] | None = None,
+        filter: Callable[[Expr], bool] | None = None,
         traverse_matches: bool = True,
     ) -> Iterator[T]:
         """
@@ -339,11 +339,7 @@ class Expr(abc.ABC):
     @overload
     @classmethod
     def list_subexprs(
-        cls,
-        expr_list: Iterable[Expr],
-        *,
-        filter: Optional[Callable[[Expr], bool]] = None,
-        traverse_matches: bool = True,
+        cls, expr_list: Iterable[Expr], *, filter: Callable[[Expr], bool] | None = None, traverse_matches: bool = True
     ) -> Iterator[Expr]: ...
 
     @overload
@@ -352,7 +348,7 @@ class Expr(abc.ABC):
         cls,
         expr_list: Iterable[Expr],
         expr_class: type[T],
-        filter: Optional[Callable[[Expr], bool]] = None,
+        filter: Callable[[Expr], bool] | None = None,
         traverse_matches: bool = True,
     ) -> Iterator[T]: ...
 
@@ -360,15 +356,24 @@ class Expr(abc.ABC):
     def list_subexprs(
         cls,
         expr_list: Iterable[Expr],
-        expr_class: Optional[type[T]] = None,
-        filter: Optional[Callable[[Expr], bool]] = None,
+        expr_class: type[T] | None = None,
+        filter: Callable[[Expr], bool] | None = None,
         traverse_matches: bool = True,
     ) -> Iterator[T]:
         """Produce subexprs for all exprs in list. Can contain duplicates."""
         for e in expr_list:
             yield from e.subexprs(expr_class=expr_class, filter=filter, traverse_matches=traverse_matches)
 
-    def _contains(self, cls: Optional[type[Expr]] = None, filter: Optional[Callable[[Expr], bool]] = None) -> bool:
+    @classmethod
+    def list_contains(
+        cls,
+        expr_list: Iterable[Expr],
+        expr_class: type[Expr] | None = None,
+        filter: Callable[[Expr], bool] | None = None,
+    ) -> bool:
+        return any(e._contains(expr_class, filter) for e in expr_list)
+
+    def _contains(self, cls: type[Expr] | None = None, filter: Callable[[Expr], bool] | None = None) -> bool:
         """
         Returns True if any subexpr is an instance of cls and/or matches filter.
         """
@@ -387,34 +392,36 @@ class Expr(abc.ABC):
         from .column_ref import ColumnRef
         from .rowid_ref import RowidRef
 
-        return {ref.col.tbl.id for ref in self.subexprs(ColumnRef)} | {ref.tbl.id for ref in self.subexprs(RowidRef)}
+        return {ref.col.get_tbl().id for ref in self.subexprs(ColumnRef)} | {
+            ref.tbl.id for ref in self.subexprs(RowidRef)
+        }
 
     @classmethod
     def all_tbl_ids(cls, exprs_: Iterable[Expr]) -> set[UUID]:
         return {tbl_id for e in exprs_ for tbl_id in e.tbl_ids()}
 
     @classmethod
-    def get_refd_columns(cls, expr_dict: dict[str, Any]) -> list[catalog.Column]:
+    def get_refd_column_ids(cls, expr_dict: dict[str, Any]) -> set[catalog.QColumnId]:
         """Return Columns referenced by expr_dict."""
-        result: list[catalog.Column] = []
+        result: set[catalog.QColumnId] = set()
         assert '_classname' in expr_dict
         from .column_ref import ColumnRef
 
         if expr_dict['_classname'] == 'ColumnRef':
-            result.append(ColumnRef.get_column(expr_dict))
+            result.add(ColumnRef.get_column_id(expr_dict))
         if 'components' in expr_dict:
             for component_dict in expr_dict['components']:
-                result.extend(cls.get_refd_columns(component_dict))
+                result.update(cls.get_refd_column_ids(component_dict))
         return result
 
-    def as_literal(self) -> Optional[Expr]:
+    def as_literal(self) -> Expr | None:
         """
         Return a Literal expression if this expression can be evaluated to a constant value, otherwise return None.
         """
         return None
 
     @classmethod
-    def from_array(cls, elements: Iterable) -> Optional[Expr]:
+    def from_array(cls, elements: Iterable) -> Expr | None:
         from .inline_expr import InlineArray
         from .literal import Literal
 
@@ -437,7 +444,7 @@ class Expr(abc.ABC):
             return self
 
     @classmethod
-    def from_object(cls, o: object) -> Optional[Expr]:
+    def from_object(cls, o: object) -> Expr | None:
         """
         Try to turn a literal object into an Expr.
         """
@@ -467,7 +474,7 @@ class Expr(abc.ABC):
                 return Literal(o, col_type=obj_type)
         return None
 
-    def sql_expr(self, sql_elements: 'exprs.SqlElementCache') -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: 'exprs.SqlElementCache') -> sql.ColumnElement | None:
         """
         If this expr can be materialized directly in SQL:
         - returns a ColumnElement
@@ -486,6 +493,18 @@ class Expr(abc.ABC):
         """
         pass
 
+    def prepare(self) -> None:
+        """
+        Create execution state. This is called before the first eval() call.
+        """
+        for c in self.components:
+            c.prepare()
+
+    @classmethod
+    def prepare_list(cls, expr_list: Iterable[Expr]) -> None:
+        for e in expr_list:
+            e.prepare()
+
     def release(self) -> None:
         """
         Allow Expr class to tear down execution state. This is called after the last eval() call.
@@ -494,7 +513,7 @@ class Expr(abc.ABC):
             c.release()
 
     @classmethod
-    def release_list(cls, expr_list: list[Expr]) -> None:
+    def release_list(cls, expr_list: Iterable[Expr]) -> None:
         for e in expr_list:
             e.release()
 
@@ -550,7 +569,7 @@ class Expr(abc.ABC):
         else:
             return InPredicate(self, value_set_literal=value_set)
 
-    def astype(self, new_type: Union[ts.ColumnType, type, _AnnotatedAlias]) -> 'exprs.TypeCast':
+    def astype(self, new_type: ts.ColumnType | type | _AnnotatedAlias) -> 'exprs.TypeCast':
         from pixeltable.exprs import TypeCast
 
         # Interpret the type argument the same way we would if given in a schema
@@ -562,7 +581,7 @@ class Expr(abc.ABC):
         return TypeCast(self, col_type)
 
     def apply(
-        self, fn: Callable, *, col_type: Union[ts.ColumnType, type, _AnnotatedAlias, None] = None
+        self, fn: Callable, *, col_type: ts.ColumnType | type | _AnnotatedAlias | None = None
     ) -> 'exprs.FunctionCall':
         if col_type is not None:
             col_type = ts.ColumnType.normalize_type(col_type)
@@ -646,7 +665,7 @@ class Expr(abc.ABC):
 
     def _make_comparison(self, op: ComparisonOperator, other: object) -> 'exprs.Comparison':
         """
-        other: Union[Expr, LiteralPythonTypes]
+        other: Expr | LiteralPythonTypes
         """
         # TODO: check for compatibility
         from .comparison import Comparison
@@ -661,7 +680,7 @@ class Expr(abc.ABC):
     def __neg__(self) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.MUL, -1)
 
-    def __add__(self, other: object) -> Union[exprs.ArithmeticExpr, exprs.StringOp]:
+    def __add__(self, other: object) -> exprs.ArithmeticExpr | exprs.StringOp:
         if isinstance(self, str) or (isinstance(self, Expr) and self.col_type.is_string_type()):
             return self._make_string_expr(StringOperator.CONCAT, other)
         return self._make_arithmetic_expr(ArithmeticOperator.ADD, other)
@@ -669,7 +688,7 @@ class Expr(abc.ABC):
     def __sub__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.SUB, other)
 
-    def __mul__(self, other: object) -> Union['exprs.ArithmeticExpr', 'exprs.StringOp']:
+    def __mul__(self, other: object) -> 'exprs.ArithmeticExpr' | 'exprs.StringOp':
         if isinstance(self, str) or (isinstance(self, Expr) and self.col_type.is_string_type()):
             return self._make_string_expr(StringOperator.REPEAT, other)
         return self._make_arithmetic_expr(ArithmeticOperator.MUL, other)
@@ -683,7 +702,7 @@ class Expr(abc.ABC):
     def __floordiv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
 
-    def __radd__(self, other: object) -> Union['exprs.ArithmeticExpr', 'exprs.StringOp']:
+    def __radd__(self, other: object) -> 'exprs.ArithmeticExpr' | 'exprs.StringOp':
         if isinstance(other, str) or (isinstance(other, Expr) and other.col_type.is_string_type()):
             return self._rmake_string_expr(StringOperator.CONCAT, other)
         return self._rmake_arithmetic_expr(ArithmeticOperator.ADD, other)
@@ -691,7 +710,7 @@ class Expr(abc.ABC):
     def __rsub__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.SUB, other)
 
-    def __rmul__(self, other: object) -> Union['exprs.ArithmeticExpr', 'exprs.StringOp']:
+    def __rmul__(self, other: object) -> 'exprs.ArithmeticExpr' | 'exprs.StringOp':
         if isinstance(other, str) or (isinstance(other, Expr) and other.col_type.is_string_type()):
             return self._rmake_string_expr(StringOperator.REPEAT, other)
         return self._rmake_arithmetic_expr(ArithmeticOperator.MUL, other)
@@ -733,7 +752,7 @@ class Expr(abc.ABC):
 
     def _make_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'exprs.ArithmeticExpr':
         """
-        other: Union[Expr, LiteralPythonTypes]
+        other: Expr | LiteralPythonTypes
         """
         # TODO: check for compatibility
         from .arithmetic_expr import ArithmeticExpr
@@ -782,7 +801,7 @@ class Expr(abc.ABC):
 
         return CompoundPredicate(LogicalOperator.NOT, [self])
 
-    def split_conjuncts(self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
+    def split_conjuncts(self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Expr | None]:
         """
         Returns clauses of a conjunction that meet condition in the first element.
         The second element contains remaining clauses, rolled into a conjunction.
@@ -793,7 +812,7 @@ class Expr(abc.ABC):
         else:
             return [], self
 
-    def _make_applicator_function(self, fn: Callable, col_type: Optional[ts.ColumnType]) -> 'func.Function':
+    def _make_applicator_function(self, fn: Callable, col_type: ts.ColumnType | None) -> 'func.Function':
         """
         Creates a unary pixeltable `Function` that encapsulates a python `Callable`. The result type of
         the new `Function` is given by `col_type`, and its parameter type will be `self.col_type`.

pixeltable/exprs/expr_dict.py

@@ -1,4 +1,4 @@
-from typing import Generic, Iterable, Iterator, Optional, TypeVar
+from typing import Generic, Iterable, Iterator, TypeVar
 
 from .expr import Expr
 
@@ -14,7 +14,7 @@ class ExprDict(Generic[T]):
 
     _data: dict[int, tuple[Expr, T]]
 
-    def __init__(self, iterable: Optional[Iterable[tuple[Expr, T]]] = None):
+    def __init__(self, iterable: Iterable[tuple[Expr, T]] | None = None):
         self._data = {}
 
         if iterable is not None:
@@ -39,7 +39,7 @@ class ExprDict(Generic[T]):
     def __contains__(self, key: Expr) -> bool:
         return key.id in self._data
 
-    def get(self, key: Expr, default: Optional[T] = None) -> Optional[T]:
+    def get(self, key: Expr, default: T | None = None) -> T | None:
         item = self._data.get(key.id)
         return item[1] if item is not None else default