pixeltable 0.4.18__py3-none-any.whl → 0.4.19__py3-none-any.whl

pixeltable/exprs/expr_set.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Generic, Iterable, Iterator, Optional, TypeVar
+from typing import Generic, Iterable, Iterator, TypeVar
 
 from .expr import Expr
 
@@ -17,7 +17,7 @@ class ExprSet(Generic[T]):
     expr_offsets: dict[int, int]  # key: Expr.id, value: offset into self.exprs.keys()
     exprs_by_idx: dict[int, T]  # key: slot_idx
 
-    def __init__(self, elements: Optional[Iterable[T]] = None):
+    def __init__(self, elements: Iterable[T] | None = None):
         self.exprs = {}
         self.expr_offsets = {}
         self.exprs_by_idx = {}
@@ -51,7 +51,7 @@ class ExprSet(Generic[T]):
     def __iter__(self) -> Iterator[T]:
         return iter(self.exprs.values())
 
-    def __getitem__(self, index: object) -> Optional[T]:
+    def __getitem__(self, index: object) -> T | None:
         """Indexed lookup by slot_idx or Expr.id."""
         assert isinstance(index, (int, Expr))
         if isinstance(index, int):

pixeltable/exprs/function_call.py

@@ -4,7 +4,7 @@ import inspect
 import logging
 import sys
 from textwrap import dedent
-from typing import Any, Optional, Sequence
+from typing import Any, Sequence
 
 import sqlalchemy as sql
 
@@ -24,7 +24,7 @@ class FunctionCall(Expr):
     fn: func.Function
     is_method_call: bool
     agg_init_args: dict[str, Any]
-    resource_pool: Optional[str]
+    resource_pool: str | None
 
     # These collections hold the component indices corresponding to the args and kwargs
     # that were passed to the FunctionCall. They're 1:1 with the original call pattern.
@@ -43,10 +43,10 @@ class FunctionCall(Expr):
     group_by_stop_idx: int
     fn_expr_idx: int
     order_by_start_idx: int
-    aggregator: Optional[Any]
-    current_partition_vals: Optional[list[Any]]
+    aggregator: Any | None
+    current_partition_vals: list[Any] | None
 
-    _validation_error: Optional[str]
+    _validation_error: str | None
 
     def __init__(
         self,
@@ -54,10 +54,10 @@ class FunctionCall(Expr):
         args: list[Expr],
         kwargs: dict[str, Expr],
         return_type: ts.ColumnType,
-        order_by_clause: Optional[list[Any]] = None,
-        group_by_clause: Optional[list[Any]] = None,
+        order_by_clause: list[Any] | None = None,
+        group_by_clause: list[Any] | None = None,
         is_method_call: bool = False,
-        validation_error: Optional[str] = None,
+        validation_error: str | None = None,
     ):
         assert not fn.is_polymorphic
         assert all(isinstance(arg, Expr) for arg in args)
@@ -149,7 +149,7 @@ class FunctionCall(Expr):
         target = tbl._tbl_version_path.tbl_version
         return [RowidRef(target, i) for i in range(target.get().num_rowid_columns())]
 
-    def default_column_name(self) -> Optional[str]:
+    def default_column_name(self) -> str | None:
         return self.fn.name
 
     def _equals(self, other: FunctionCall) -> bool:
@@ -178,7 +178,7 @@ class FunctionCall(Expr):
         return self.display_str()
 
     @property
-    def validation_error(self) -> Optional[str]:
+    def validation_error(self) -> str | None:
         return self._validation_error or super().validation_error
 
     def display_str(self, inline: bool = True) -> str:
@@ -245,7 +245,7 @@ class FunctionCall(Expr):
         assert self.is_agg_fn_call
         return self.order_by
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> sql.ColumnElement | None:
         assert self.is_valid
 
         # we currently can't translate aggregate functions with grouping and/or ordering to SQL
@@ -321,7 +321,7 @@ class FunctionCall(Expr):
         args, kwargs = self.make_args(data_row)
         self.aggregator.update(*args, **kwargs)
 
-    def make_args(self, data_row: DataRow) -> Optional[tuple[list[Any], dict[str, Any]]]:
+    def make_args(self, data_row: DataRow) -> tuple[list[Any], dict[str, Any]] | None:
         """Return args and kwargs, constructed for data_row; returns None if any non-nullable arg is None."""
         args: list[Any] = []
         parameters_by_pos = self.fn.signature.parameters_by_pos
@@ -448,7 +448,7 @@ class FunctionCall(Expr):
         group_by_exprs = components[group_by_start_idx:group_by_stop_idx]
         order_by_exprs = components[order_by_start_idx:]
 
-        validation_error: Optional[str] = None
+        validation_error: str | None = None
 
         if isinstance(fn, func.InvalidFunction):
             validation_error = (
@@ -489,7 +489,7 @@ class FunctionCall(Expr):
             ).strip()
         else:
             # Evaluate the call_return_type as defined in the current codebase.
-            call_return_type: Optional[ts.ColumnType] = None
+            call_return_type: ts.ColumnType | None = None
 
             if isinstance(resolved_fn, func.ExprTemplateFunction) and not resolved_fn.template.expr.is_valid:
                 # The FunctionCall is based on an ExprTemplateFunction, but the template expression is not valid

pixeltable/exprs/in_predicate.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional
+from typing import Any, Iterable
 
 import sqlalchemy as sql
 
@@ -16,13 +16,13 @@ from .sql_element_cache import SqlElementCache
 class InPredicate(Expr):
     """Predicate corresponding to the SQL IN operator."""
 
-    def __init__(self, lhs: Expr, value_set_literal: Optional[Iterable] = None, value_set_expr: Optional[Expr] = None):
+    def __init__(self, lhs: Expr, value_set_literal: Iterable | None = None, value_set_expr: Expr | None = None):
         assert (value_set_literal is None) != (value_set_expr is None)
         if not lhs.col_type.is_scalar_type():
             raise excs.Error(f'isin(): only supported for scalar types, not {lhs.col_type}')
         super().__init__(ts.BoolType())
 
-        self.value_list: Optional[list] = None  # only contains values of the correct type
+        self.value_list: list | None = None  # only contains values of the correct type
         if value_set_expr is not None:
             if not value_set_expr.col_type.is_json_type():
                 raise excs.Error(
@@ -73,7 +73,7 @@ class InPredicate(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('value_list', self.value_list)]
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> sql.ColumnElement | None:
         lhs_sql_exprs = sql_elements.get(self.components[0])
         if lhs_sql_exprs is None or self.value_list is None:
             return None

pixeltable/exprs/inline_expr.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional
+from typing import Any, Iterable
 
 import numpy as np
 import sqlalchemy as sql
@@ -30,7 +30,7 @@ class InlineArray(Expr):
             else:
                 exprs.append(Literal(el))
 
-        inferred_element_type: Optional[ts.ColumnType] = ts.InvalidType()
+        inferred_element_type: ts.ColumnType | None = ts.InvalidType()
         for i, expr in enumerate(exprs):
             supertype = inferred_element_type.supertype(expr.col_type)
             if supertype is None:
@@ -61,7 +61,7 @@ class InlineArray(Expr):
     def _equals(self, _: InlineArray) -> bool:
         return True  # Always true if components match
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
@@ -81,7 +81,7 @@ class InlineArray(Expr):
             # loaded and their types are known.
             return InlineList(components)  # type: ignore[return-value]
 
-    def as_literal(self) -> Optional[Literal]:
+    def as_literal(self) -> Literal | None:
         assert isinstance(self.col_type, ts.ArrayType)
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
@@ -109,7 +109,7 @@ class InlineList(Expr):
     def _equals(self, _: InlineList) -> bool:
         return True  # Always true if components match
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, _: RowBuilder) -> None:
@@ -122,7 +122,7 @@ class InlineList(Expr):
     def _from_dict(cls, _: dict, components: list[Expr]) -> InlineList:
         return cls(components)
 
-    def as_literal(self) -> Optional[Literal]:
+    def as_literal(self) -> Literal | None:
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
         return Literal([c.as_literal().val for c in self.components], self.col_type)
@@ -159,7 +159,7 @@ class InlineDict(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('keys', self.keys)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, _: RowBuilder) -> None:
@@ -191,7 +191,7 @@ class InlineDict(Expr):
         arg = dict(zip(d['keys'], components))
         return InlineDict(arg)
 
-    def as_literal(self) -> Optional[Literal]:
+    def as_literal(self) -> Literal | None:
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
         return Literal(dict(zip(self.keys, (c.as_literal().val for c in self.components))), self.col_type)

pixeltable/exprs/is_null.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import sqlalchemy as sql
 
 import pixeltable.type_system as ts
@@ -24,7 +22,7 @@ class IsNull(Expr):
     def _equals(self, other: IsNull) -> bool:
         return True
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> sql.ColumnElement | None:
         e = sql_elements.get(self.components[0])
         if e is None:
             return None

pixeltable/exprs/json_mapper.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import sqlalchemy as sql
 
@@ -29,10 +29,10 @@ class JsonMapper(Expr):
     """
 
     target_expr_scope: ExprScope
-    parent_mapper: Optional[JsonMapper]
-    target_expr_eval_ctx: Optional[RowBuilder.EvalCtx]
+    parent_mapper: JsonMapper | None
+    target_expr_eval_ctx: RowBuilder.EvalCtx | None
 
-    def __init__(self, src_expr: Optional[Expr], target_expr: Optional[Expr]):
+    def __init__(self, src_expr: Expr | None, target_expr: Expr | None):
         # TODO: type spec should be list[target_expr.col_type]
         super().__init__(ts.JsonType())
 
@@ -54,7 +54,7 @@ class JsonMapper(Expr):
     def _equals(self, _: JsonMapper) -> bool:
         return True
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
@@ -92,8 +92,8 @@ class JsonMapperDispatch(Expr):
     """
 
     target_expr_scope: ExprScope
-    parent_mapper: Optional[JsonMapperDispatch]
-    target_expr_eval_ctx: Optional[RowBuilder.EvalCtx]
+    parent_mapper: JsonMapperDispatch | None
+    target_expr_eval_ctx: RowBuilder.EvalCtx | None
 
     def __init__(self, src_expr: Expr, target_expr: Expr):
         super().__init__(ts.InvalidType())
@@ -116,7 +116,7 @@ class JsonMapperDispatch(Expr):
         scope_anchor = ObjectRef(self.target_expr_scope, self)
         self.components.append(scope_anchor)
 
-    def _bind_rel_paths(self, mapper: Optional[JsonMapperDispatch] = None) -> None:
+    def _bind_rel_paths(self, mapper: JsonMapperDispatch | None = None) -> None:
         self.src_expr._bind_rel_paths(mapper)
         self.target_expr._bind_rel_paths(self)
         self.parent_mapper = mapper

pixeltable/exprs/json_path.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import io
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import jmespath
 import sqlalchemy as sql
@@ -32,7 +32,7 @@ class JsonPath(Expr):
     file_handles: dict[Path, io.BufferedReader]  # key: file path
 
     def __init__(
-        self, anchor: Optional[Expr], path_elements: Optional[list[str | int | slice]] = None, scope_idx: int = 0
+        self, anchor: Expr | None, path_elements: list[str | int | slice] | None = None, scope_idx: int = 0
     ) -> None:
         if path_elements is None:
             path_elements = []
@@ -81,7 +81,7 @@ class JsonPath(Expr):
         return cls(anchor, path_elements, d['scope_idx'])
 
     @property
-    def anchor(self) -> Optional[Expr]:
+    def anchor(self) -> Expr | None:
         return None if len(self.components) == 0 else self.components[0]
 
     def set_anchor(self, anchor: Expr) -> None:
@@ -94,7 +94,7 @@ class JsonPath(Expr):
     def _has_relative_path(self) -> bool:
         return self.is_relative_path() or super()._has_relative_path()
 
-    def _bind_rel_paths(self, mapper: Optional['JsonMapperDispatch'] = None) -> None:
+    def _bind_rel_paths(self, mapper: 'JsonMapperDispatch' | None = None) -> None:
         if self.is_relative_path():
             # TODO: take scope_idx into account
             self.set_anchor(mapper.scope_anchor)
@@ -120,7 +120,7 @@ class JsonPath(Expr):
             return JsonPath(self.anchor, [*self.path_elements, index])
         raise excs.Error(f'Invalid json list index: {index}')
 
-    def default_column_name(self) -> Optional[str]:
+    def default_column_name(self) -> str | None:
         anchor_name = self.anchor.default_column_name() if self.anchor is not None else ''
         ret_name = f'{anchor_name}.{self._json_path()}'
 
@@ -148,7 +148,7 @@ class JsonPath(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('path_elements', self.path_elements)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         """
         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].

pixeltable/exprs/literal.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import datetime
-from typing import Any, Optional
+from typing import Any
 
 import numpy as np
 import sqlalchemy as sql
@@ -18,7 +18,7 @@ from .sql_element_cache import SqlElementCache
 class Literal(Expr):
     val: Any
 
-    def __init__(self, val: Any, col_type: Optional[ts.ColumnType] = None):
+    def __init__(self, val: Any, col_type: ts.ColumnType | None = None):
         if col_type is not None:
             val = col_type.create_literal(val)
         else:
@@ -42,7 +42,7 @@ class Literal(Expr):
         self.val = val
         self.id = self._create_id()
 
-    def default_column_name(self) -> Optional[str]:
+    def default_column_name(self) -> str | None:
         return 'Literal'
 
     def __str__(self) -> str:
@@ -69,7 +69,7 @@ class Literal(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('val', self.val)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         # Return a sql object so that constants can participate in SQL expressions
         return sql.sql.expression.literal(self.val, type_=self.col_type.to_sa_type())
 
@@ -97,7 +97,7 @@ class Literal(Expr):
         else:
             return {'val': self.val, **super()._as_dict()}
 
-    def as_literal(self) -> Optional[Literal]:
+    def as_literal(self) -> Literal | None:
         return self
 
     @classmethod

pixeltable/exprs/method_ref.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 import sqlalchemy as sql
 
@@ -55,7 +55,7 @@ class MethodRef(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('method_name', self.method_name)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/object_ref.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 import sqlalchemy as sql
 
@@ -43,7 +43,7 @@ class ObjectRef(Expr):
     def _equals(self, other: ObjectRef) -> bool:
         return self.id == other.id
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/row_builder.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import dataclasses
 import sys
 import time
-from typing import Any, Iterable, NamedTuple, Optional, Sequence
+from typing import Any, Iterable, NamedTuple, Sequence
 from uuid import UUID
 
 import numpy as np
@@ -69,7 +69,7 @@ class RowBuilder:
 
     input_exprs: ExprSet
 
-    tbl: Optional[catalog.TableVersion]  # reference table of the RowBuilder; used to identify pk columns for writes
+    tbl: catalog.TableVersion | None  # reference table of the RowBuilder; used to identify pk columns for writes
     table_columns: dict[catalog.Column, int | None]  # value: slot idx, if the result of an expr
     default_eval_ctx: EvalCtx
     unstored_iter_args: dict[UUID, Expr]
@@ -110,7 +110,7 @@ class RowBuilder:
         output_exprs: Sequence[Expr],
         columns: Sequence[catalog.Column],
         input_exprs: Iterable[Expr],
-        tbl: Optional[catalog.TableVersion] = None,
+        tbl: catalog.TableVersion | None = None,
     ):
         self.unique_exprs: ExprSet[Expr] = ExprSet()  # dependencies precede their dependents
         self.next_slot_idx = 0
@@ -183,18 +183,18 @@ class RowBuilder:
         col_refs = [e for e in self.unique_exprs if isinstance(e, ColumnRef)]
 
         def refs_unstored_iter_col(col_ref: ColumnRef) -> bool:
-            tbl = col_ref.col.tbl
+            tbl = col_ref.col.get_tbl()
             return tbl.is_component_view and tbl.is_iterator_column(col_ref.col) and not col_ref.col.is_stored
 
         unstored_iter_col_refs = [col_ref for col_ref in col_refs if refs_unstored_iter_col(col_ref)]
-        component_views = [col_ref.col.tbl for col_ref in unstored_iter_col_refs]
+        component_views = [col_ref.col.get_tbl() for col_ref in unstored_iter_col_refs]
         unstored_iter_args = {view.id: view.iterator_args.copy() for view in component_views}
         self.unstored_iter_args = {
             id: self._record_unique_expr(arg, recursive=True) for id, arg in unstored_iter_args.items()
         }
 
         for col_ref in unstored_iter_col_refs:
-            iter_arg_ctx = self.create_eval_ctx([unstored_iter_args[col_ref.col.tbl.id]])
+            iter_arg_ctx = self.create_eval_ctx([unstored_iter_args[col_ref.col.get_tbl().id]])
             col_ref.set_iter_arg_ctx(iter_arg_ctx)
 
         # we guarantee that we can compute the expr DAG in a single front-to-back pass
@@ -308,7 +308,7 @@ class RowBuilder:
             self._record_output_expr_id(d, output_expr_id)
 
     def _compute_dependencies(
-        self, target_slot_idxs: list[int], excluded_slot_idxs: list[int], target_scope: Optional[ExprScope] = None
+        self, target_slot_idxs: list[int], excluded_slot_idxs: list[int], target_scope: ExprScope | None = None
     ) -> list[int]:
         """Compute exprs needed to materialize the given target slots, excluding 'excluded_slot_idxs'
 
@@ -362,7 +362,7 @@ class RowBuilder:
             self.__set_slot_idxs_aux(c)
 
     def get_dependencies(
-        self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None, limit_scope: bool = True
+        self, targets: Iterable[Expr], exclude: Iterable[Expr] | None = None, limit_scope: bool = True
     ) -> list[Expr]:
         """
         Return list of dependencies needed to evaluate the given target exprs (expressed as slot idxs).
@@ -380,7 +380,7 @@ 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
+        target_scope: ExprScope | None = None
         if limit_scope:
             # make sure all targets are from the same scope
             target_scopes = {e.scope() for e in targets}
@@ -398,7 +398,7 @@ class RowBuilder:
         return [self.unique_exprs[id] for id in result_ids]
 
     def create_eval_ctx(
-        self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None, limit_scope: bool = True
+        self, targets: Iterable[Expr], exclude: Iterable[Expr] | None = None, limit_scope: bool = True
     ) -> EvalCtx:
         """Return EvalCtx for targets"""
         targets = list(targets)
@@ -427,9 +427,9 @@ class RowBuilder:
         self,
         data_row: DataRow,
         ctx: EvalCtx,
-        profile: Optional[ExecProfile] = None,
+        profile: ExecProfile | None = None,
         ignore_errors: bool = False,
-        force_eval: Optional[ExprScope] = None,
+        force_eval: ExprScope | None = None,
     ) -> None:
         """
         Populates the slots in data_row given in ctx.
@@ -459,7 +459,7 @@ class RowBuilder:
                     ) from exc
 
     def create_store_table_row(
-        self, data_row: DataRow, cols_with_excs: Optional[set[int]], pk: tuple[int, ...]
+        self, data_row: DataRow, cols_with_excs: set[int] | None, pk: tuple[int, ...]
     ) -> tuple[list[Any], int]:
         """Create a store table row from the slots that have an output column assigned
 
@@ -499,7 +499,7 @@ class RowBuilder:
                     # exceptions get stored in the errortype/-msg properties of the cellmd column
                     table_row.append(ColumnPropertyRef.create_cellmd_exc(exc))
             else:
-                val = data_row.get_stored_val(slot_idx, col.get_sa_col_type())
+                val = data_row.get_stored_val(slot_idx, col.sa_col_type)
                 table_row.append(val)
                 if col.stores_cellmd:
                     table_row.append(sql.sql.null())  # placeholder for cellmd column

pixeltable/exprs/rowid_ref.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Optional, cast
+from typing import Any, cast
 from uuid import UUID
 
 import sqlalchemy as sql
@@ -25,18 +25,18 @@ class RowidRef(Expr):
     (with and without a TableVersion).
     """
 
-    tbl: Optional[catalog.TableVersionHandle]
-    normalized_base: Optional[catalog.TableVersionHandle]
+    tbl: catalog.TableVersionHandle | None
+    normalized_base: catalog.TableVersionHandle | None
     tbl_id: UUID
     normalized_base_id: UUID
     rowid_component_idx: int
 
     def __init__(
         self,
-        tbl: Optional[catalog.TableVersionHandle],
+        tbl: catalog.TableVersionHandle | None,
         idx: int,
-        tbl_id: Optional[UUID] = None,
-        normalized_base_id: Optional[UUID] = None,
+        tbl_id: UUID | None = None,
+        normalized_base_id: UUID | None = None,
     ):
         super().__init__(ts.IntType(nullable=False))
         self.tbl = tbl
@@ -57,7 +57,7 @@ class RowidRef(Expr):
         self.rowid_component_idx = idx
         self.id = self._create_id()
 
-    def default_column_name(self) -> Optional[str]:
+    def default_column_name(self) -> str | None:
         return str(self)
 
     def _equals(self, other: RowidRef) -> bool:
@@ -98,7 +98,7 @@ class RowidRef(Expr):
         self.tbl = tbl.tbl_version
         self.tbl_id = self.tbl.id
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         tbl = self.tbl.get() if self.tbl is not None else catalog.Catalog.get().get_tbl_version(self.tbl_id, None)
         assert tbl.is_validated
         rowid_cols = tbl.store_tbl.rowid_columns()