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

pixeltable/catalog/column.py

@@ -3,21 +3,21 @@ from __future__ import annotations
 import logging
 import warnings
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import sqlalchemy as sql
 
 import pixeltable.exceptions as excs
+import pixeltable.exprs as exprs
 import pixeltable.type_system as ts
-from pixeltable import exprs
+from pixeltable.env import Env
 from pixeltable.metadata import schema
 
-from .globals import MediaValidation, is_valid_identifier
+from .globals import MediaValidation, QColumnId, is_valid_identifier
 
 if TYPE_CHECKING:
     from .table_version import TableVersion
-    from .table_version_handle import ColumnHandle
-    from .table_version_path import TableVersionPath
+    from .table_version_handle import ColumnHandle, TableVersionHandle
 
 _logger = logging.getLogger('pixeltable')
 
@@ -48,57 +48,58 @@ class Column:
     - if None: the system chooses for you (at present, this is always False, but this may change in the future)
     """
 
-    name: Optional[str]
-    id: Optional[int]
+    name: str | None
+    id: int | None
     col_type: ts.ColumnType
     stored: bool
     is_pk: bool
-    destination: Optional[str]  # An object store reference for computed files
-    _media_validation: Optional[MediaValidation]  # if not set, TableVersion.media_validation applies
-    schema_version_add: Optional[int]
-    schema_version_drop: Optional[int]
-    _stores_cellmd: Optional[bool]
-    sa_col: Optional[sql.schema.Column]
-    sa_col_type: Optional[sql.sqltypes.TypeEngine]
-    sa_cellmd_col: Optional[sql.schema.Column]  # JSON metadata for the cell, e.g. errortype, errormsg for media columns
-    _value_expr: Optional[exprs.Expr]
-    value_expr_dict: Optional[dict[str, Any]]
-    # we store a TableVersion here, not a TableVersionHandle, because this column is owned by that TableVersion instance
-    # (re-resolving it later to a different instance doesn't make sense)
-    tbl: Optional[TableVersion]
+    is_iterator_col: bool
+    _explicit_destination: str | None  # An object store reference for computed files
+    _media_validation: MediaValidation | None  # if not set, TableVersion.media_validation applies
+    schema_version_add: int | None
+    schema_version_drop: int | None
+    stores_cellmd: bool
+    sa_col: sql.schema.Column | None
+    sa_col_type: sql.types.TypeEngine
+    sa_cellmd_col: sql.schema.Column | None  # JSON metadata for the cell, e.g. errortype, errormsg for media columns
+    _value_expr: exprs.Expr | None
+    value_expr_dict: dict[str, Any] | None
+    # we store a handle here in order to allow Column construction before there is a corresponding TableVersion
+    tbl_handle: 'TableVersionHandle' | None
 
     def __init__(
         self,
-        name: Optional[str],
-        col_type: Optional[ts.ColumnType] = None,
-        computed_with: Optional[exprs.Expr] = None,
+        name: str | None,
+        col_type: ts.ColumnType | None = None,
+        computed_with: exprs.Expr | None = None,
         is_pk: bool = False,
+        is_iterator_col: bool = False,
         stored: bool = True,
-        media_validation: Optional[MediaValidation] = None,
-        col_id: Optional[int] = None,
-        schema_version_add: Optional[int] = None,
-        schema_version_drop: Optional[int] = None,
-        sa_col_type: Optional[sql.sqltypes.TypeEngine] = None,
-        stores_cellmd: Optional[bool] = None,
-        value_expr_dict: Optional[dict[str, Any]] = None,
-        tbl: Optional[TableVersion] = None,
-        destination: Optional[str] = None,
+        media_validation: MediaValidation | None = None,
+        col_id: int | None = None,
+        schema_version_add: int | None = None,
+        schema_version_drop: int | None = None,
+        sa_col_type: sql.types.TypeEngine | None = None,
+        stores_cellmd: bool | None = None,
+        value_expr_dict: dict[str, Any] | None = None,
+        tbl_handle: 'TableVersionHandle' | None = None,
+        destination: str | None = None,
     ):
         if name is not None and not is_valid_identifier(name):
-            raise excs.Error(f"Invalid column name: '{name}'")
+            raise excs.Error(f'Invalid column name: {name}')
         self.name = name
-        self.tbl = tbl
+        self.tbl_handle = tbl_handle
         if col_type is None and computed_with is None:
-            raise excs.Error(f'Column `{name}`: col_type is required if computed_with is not specified')
+            raise excs.Error(f'Column {name!r}: `col_type` is required if `computed_with` is not specified')
 
-        self._value_expr: Optional[exprs.Expr] = None
+        self._value_expr = None
         self.value_expr_dict = value_expr_dict
         if computed_with is not None:
             value_expr = exprs.Expr.from_object(computed_with)
             if value_expr is None:
                 # TODO: this shouldn't be a user-facing error
                 raise excs.Error(
-                    f'Column {name}: computed_with needs to be a valid Pixeltable expression, '
+                    f'Column {name!r}: `computed_with` needs to be a valid Pixeltable expression, '
                     f'but it is a {type(computed_with)}'
                 )
             else:
@@ -115,21 +116,30 @@ class Column:
         # self.dependent_cols = set()  # cols with value_exprs that reference us; set by TableVersion
         self.id = col_id
         self.is_pk = is_pk
+        self.is_iterator_col = is_iterator_col
         self._media_validation = media_validation
         self.schema_version_add = schema_version_add
         self.schema_version_drop = schema_version_drop
 
-        self._stores_cellmd = stores_cellmd
+        if stores_cellmd is not None:
+            self.stores_cellmd = stores_cellmd
+        else:
+            self.stores_cellmd = stored and (
+                self.is_computed
+                or self.col_type.is_media_type()
+                or self.col_type.is_json_type()
+                or self.col_type.is_array_type()
+            )
 
         # column in the stored table for the values of this Column
         self.sa_col = None
-        self.sa_col_type = sa_col_type
+        self.sa_col_type = self.col_type.to_sa_type() if sa_col_type is None else sa_col_type
 
         # computed cols also have storage columns for the exception string and type
         self.sa_cellmd_col = None
-        self.destination = destination
+        self._explicit_destination = destination
 
-    def to_md(self, pos: Optional[int] = None) -> tuple[schema.ColumnMd, Optional[schema.SchemaColumn]]:
+    def to_md(self, pos: int | None = None) -> tuple[schema.ColumnMd, schema.SchemaColumn | None]:
         """Returns the Column and optional SchemaColumn metadata for this Column."""
         assert self.is_pk is not None
         col_md = schema.ColumnMd(
@@ -140,7 +150,7 @@ class Column:
             schema_version_drop=self.schema_version_drop,
             value_expr=self.value_expr.as_dict() if self.value_expr is not None else None,
             stored=self.stored,
-            destination=self.destination,
+            destination=self._explicit_destination,
         )
         if pos is None:
             return col_md, None
@@ -152,33 +162,6 @@ class Column:
         )
         return col_md, sch_md
 
-    @classmethod
-    def from_md(
-        cls, col_md: schema.ColumnMd, tbl: TableVersion, schema_col_md: Optional[schema.SchemaColumn]
-    ) -> Column:
-        """Create a Column from a ColumnMd."""
-        assert col_md.id is not None
-        col_name = schema_col_md.name if schema_col_md is not None else None
-        media_val = (
-            MediaValidation[schema_col_md.media_validation.upper()]
-            if schema_col_md is not None and schema_col_md.media_validation is not None
-            else None
-        )
-        col = cls(
-            col_id=col_md.id,
-            name=col_name,
-            col_type=ts.ColumnType.from_dict(col_md.col_type),
-            is_pk=col_md.is_pk,
-            stored=col_md.stored,
-            media_validation=media_val,
-            schema_version_add=col_md.schema_version_add,
-            schema_version_drop=col_md.schema_version_drop,
-            value_expr_dict=col_md.value_expr,
-            tbl=tbl,
-            destination=col_md.destination,
-        )
-        return col
-
     def init_value_expr(self) -> None:
         from pixeltable import exprs
 
@@ -190,7 +173,7 @@ class Column:
             message = (
                 dedent(
                     f"""
-                    The computed column {self.name!r} in table {self.tbl.name!r} is no longer valid.
+                    The computed column {self.name!r} in table {self.get_tbl().name!r} is no longer valid.
                     {{validation_error}}
                     You can continue to query existing data from this column, but evaluating it on new data will raise an error.
                     """  # noqa: E501
@@ -200,17 +183,46 @@ class Column:
             )
             warnings.warn(message, category=excs.PixeltableWarning, stacklevel=2)
 
+    def get_tbl(self) -> TableVersion:
+        tv = self.tbl_handle.get()
+        return tv
+
+    @property
+    def destination(self) -> str | None:
+        if self._explicit_destination is not None:
+            # An expilicit destination was set as part of the column definition
+            return self._explicit_destination
+
+        # Otherwise, if this is a stored media column, use the default destination if one is configured (input
+        #     destination or output destination, depending on whether this is a computed column)
+        # TODO: The `self.name is not None` clause is necessary because index columns currently follow the type of
+        #     the underlying media column. We should move to using pxt.String as the col_type of index columns; this
+        #     would be a more robust solution, and then `self.name is not None` could be removed.
+        if self.is_stored and self.col_type.is_media_type() and self.name is not None:
+            if self.is_computed:
+                return Env.get().default_output_media_dest
+            else:
+                return Env.get().default_input_media_dest
+
+        return None
+
     @property
     def handle(self) -> 'ColumnHandle':
         """Returns a ColumnHandle for this Column."""
         from .table_version_handle import ColumnHandle
 
-        assert self.tbl is not None
+        assert self.tbl_handle is not None
+        assert self.id is not None
+        return ColumnHandle(self.tbl_handle, self.id)
+
+    @property
+    def qid(self) -> QColumnId:
+        assert self.tbl_handle is not None
         assert self.id is not None
-        return ColumnHandle(self.tbl.handle, self.id)
+        return QColumnId(self.tbl_handle.id, self.id)
 
     @property
-    def value_expr(self) -> Optional[exprs.Expr]:
+    def value_expr(self) -> exprs.Expr | None:
         assert self.value_expr_dict is None or self._value_expr is not None
         return self._value_expr
 
@@ -220,29 +232,22 @@ class Column:
 
     def check_value_expr(self) -> None:
         assert self._value_expr is not None
-        if self.stored == False and self.is_computed and self.has_window_fn_call():
+        if not self.stored and self.is_computed and self.has_window_fn_call():
             raise excs.Error(
-                f'Column {self.name}: stored={self.stored} not supported for columns computed with window functions:'
-                f'\n{self.value_expr}'
+                f'Column {self.name!r}: `stored={self.stored}` not supported for columns '
+                f'computed with window functions:\n{self.value_expr}'
             )
 
     def has_window_fn_call(self) -> bool:
-        if self.value_expr is None:
-            return False
         from pixeltable import exprs
 
+        if self.value_expr is None:
+            return False
         window_fn_calls = list(
             self.value_expr.subexprs(filter=lambda e: isinstance(e, exprs.FunctionCall) and e.is_window_fn_call)
         )
         return len(window_fn_calls) > 0
 
-    # TODO: This should be moved out of `Column` (its presence in `Column` doesn't anticipate indices being defined on
-    #     multiple dependents)
-    def get_idx_info(self, reference_tbl: Optional['TableVersionPath'] = None) -> dict[str, 'TableVersion.IndexInfo']:
-        assert self.tbl is not None
-        tbl = reference_tbl.tbl_version.get() if reference_tbl is not None else self.tbl
-        return {name: info for name, info in tbl.idxs_by_name.items() if info.col == self}
-
     @property
     def is_computed(self) -> bool:
         return self._value_expr is not None or self.value_expr_dict is not None
@@ -253,30 +258,17 @@ class Column:
         assert self.stored is not None
         return self.stored
 
-    @property
-    def stores_cellmd(self) -> bool:
-        """True if this column also stores error information."""
-        # default: record errors for computed and media columns
-        if self._stores_cellmd is not None:
-            return self._stores_cellmd
-        return self.is_stored and (
-            self.is_computed
-            or self.col_type.is_media_type()
-            or self.col_type.is_json_type()
-            or self.col_type.is_array_type()
-        )
-
     @property
     def qualified_name(self) -> str:
-        assert self.tbl is not None
-        return f'{self.tbl.name}.{self.name}'
+        assert self.get_tbl() is not None
+        return f'{self.get_tbl().name}.{self.name}'
 
     @property
     def media_validation(self) -> MediaValidation:
         if self._media_validation is not None:
             return self._media_validation
-        assert self.tbl is not None
-        return self.tbl.media_validation
+        assert self.get_tbl() is not None
+        return self.get_tbl().media_validation
 
     @property
     def is_required_for_insert(self) -> bool:
@@ -295,24 +287,21 @@ class Column:
 
     def create_sa_cols(self) -> None:
         """
-        These need to be recreated for every new table schema version.
+        These need to be recreated for every sql.Table instance
         """
         assert self.is_stored
+        assert self.stores_cellmd is not None
         # all storage columns are nullable (we deal with null errors in Pixeltable directly)
-        self.sa_col = sql.Column(self.store_name(), self.get_sa_col_type(), nullable=True)
+        self.sa_col = sql.Column(self.store_name(), self.sa_col_type, nullable=True)
         if self.stores_cellmd:
-            # JSON metadata for the cell, e.g. errortype, errormsg for media columns
             self.sa_cellmd_col = sql.Column(self.cellmd_store_name(), self.sa_cellmd_type(), nullable=True)
 
-    def get_sa_col_type(self) -> sql.sqltypes.TypeEngine:
-        return self.col_type.to_sa_type() if self.sa_col_type is None else self.sa_col_type
-
     @classmethod
     def cellmd_type(cls) -> ts.ColumnType:
         return ts.JsonType(nullable=True)
 
     @classmethod
-    def sa_cellmd_type(cls) -> sql.sqltypes.TypeEngine:
+    def sa_cellmd_type(cls) -> sql.types.TypeEngine:
         return cls.cellmd_type().to_sa_type()
 
     def store_name(self) -> str:
@@ -327,17 +316,17 @@ class Column:
         return f'{self.name}: {self.col_type}'
 
     def __repr__(self) -> str:
-        return f'Column({self.id!r}, {self.name!r}, tbl={self.tbl.name!r})'
+        return f'Column({self.id!r}, {self.name!r}, tbl={self.get_tbl().name!r})'
 
     def __hash__(self) -> int:
         # TODO(aaron-siegel): This and __eq__ do not capture the table version. We need to rethink the Column
         #     abstraction (perhaps separating out the version-dependent properties into a different abstraction).
-        assert self.tbl is not None
-        return hash((self.tbl.id, self.id))
+        assert self.tbl_handle is not None
+        return hash((self.tbl_handle.id, self.id))
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Column):
             return False
-        assert self.tbl is not None
-        assert other.tbl is not None
-        return self.tbl.id == other.tbl.id and self.id == other.id
+        assert self.tbl_handle is not None
+        assert other.tbl_handle is not None
+        return self.tbl_handle.id == other.tbl_handle.id and self.id == other.id

pixeltable/catalog/globals.py

@@ -4,7 +4,6 @@ import enum
 import itertools
 import logging
 from dataclasses import dataclass
-from typing import Optional
 from uuid import UUID
 
 import pixeltable.exceptions as excs
@@ -17,7 +16,7 @@ _ROWID_COLUMN_NAME = '_rowid'
 
 # Set of symbols that are predefined in the `InsertableTable` class (and are therefore not allowed as column names).
 # This will be populated lazily to avoid circular imports.
-_PREDEF_SYMBOLS: Optional[set[str]] = None
+_PREDEF_SYMBOLS: set[str] | None = None
 
 
 @dataclass(frozen=True)

pixeltable/catalog/insertable_table.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import enum
 import logging
-from typing import TYPE_CHECKING, Any, Literal, Optional, Sequence, cast, overload
+from typing import TYPE_CHECKING, Any, Literal, Sequence, cast, overload
 from uuid import UUID
 
 import pydantic
@@ -16,9 +16,10 @@ from pixeltable.utils.pydantic import is_json_convertible
 
 from .globals import MediaValidation
 from .table import Table
-from .table_version import TableVersion
+from .table_version import TableVersion, TableVersionMd
 from .table_version_handle import TableVersionHandle
 from .table_version_path import TableVersionPath
+from .tbl_ops import CreateStoreTableOp, TableOp
 from .update_status import UpdateStatus
 
 if TYPE_CHECKING:
@@ -65,15 +66,14 @@ class InsertableTable(Table):
     @classmethod
     def _create(
         cls,
-        dir_id: UUID,
         name: str,
         schema: dict[str, ts.ColumnType],
-        df: Optional[pxt.DataFrame],
         primary_key: list[str],
         num_retained_versions: int,
         comment: str,
         media_validation: MediaValidation,
-    ) -> InsertableTable:
+        create_default_idxs: bool,
+    ) -> tuple[TableVersionMd, list[TableOp]]:
         columns = cls._create_columns(schema)
         cls._verify_schema(columns)
         column_names = [col.name for col in columns]
@@ -85,38 +85,35 @@ class InsertableTable(Table):
                 raise excs.Error(f'Primary key column {pk_col!r} cannot be nullable.')
             col.is_pk = True
 
-        _, tbl_version = TableVersion.create(
-            dir_id,
+        md = TableVersion.create_initial_md(
             name,
             columns,
-            num_retained_versions=num_retained_versions,
-            comment=comment,
-            media_validation=media_validation,
+            num_retained_versions,
+            comment,
+            media_validation,
+            create_default_idxs=create_default_idxs,
+            view_md=None,
         )
-        tbl = cls(dir_id, TableVersionHandle.create(tbl_version))
-        # TODO We need to commit before doing the insertion, in order to avoid a primary key (version) collision
-        #   when the table metadata gets updated. Once we have a notion of user-defined transactions in
-        #   Pixeltable, we can wrap the create/insert in a transaction to avoid this.
-        session = Env.get().session
-        session.commit()
-        if df is not None:
-            # A DataFrame was provided, so insert its contents into the table
-            # (using the same DB session as the table creation)
-            tbl_version.insert(None, df, fail_on_exception=True)
-        session.commit()
-
-        _logger.info(f'Created table {name!r}, id={tbl_version.id}')
-        Env.get().console_logger.info(f'Created table {name!r}.')
-        return tbl
+
+        ops = [
+            TableOp(
+                tbl_id=md.tbl_md.tbl_id,
+                op_sn=0,
+                num_ops=1,
+                needs_xact=False,
+                create_store_table_op=CreateStoreTableOp(),
+            )
+        ]
+        return md, ops
 
     @overload
     def insert(
         self,
-        source: Optional[TableDataSource] = None,
+        source: TableDataSource | None = None,
         /,
         *,
-        source_format: Optional[Literal['csv', 'excel', 'parquet', 'json']] = None,
-        schema_overrides: Optional[dict[str, ts.ColumnType]] = None,
+        source_format: Literal['csv', 'excel', 'parquet', 'json'] | None = None,
+        schema_overrides: dict[str, ts.ColumnType] | None = None,
         on_error: Literal['abort', 'ignore'] = 'abort',
         print_stats: bool = False,
         **kwargs: Any,
@@ -129,11 +126,11 @@ class InsertableTable(Table):
 
     def insert(
         self,
-        source: Optional[TableDataSource] = None,
+        source: TableDataSource | None = None,
         /,
         *,
-        source_format: Optional[Literal['csv', 'excel', 'parquet', 'json']] = None,
-        schema_overrides: Optional[dict[str, ts.ColumnType]] = None,
+        source_format: Literal['csv', 'excel', 'parquet', 'json'] | None = None,
+        schema_overrides: dict[str, ts.ColumnType] | None = None,
         on_error: Literal['abort', 'ignore'] = 'abort',
         print_stats: bool = False,
         **kwargs: Any,
@@ -142,7 +139,7 @@ class InsertableTable(Table):
         from pixeltable.io.table_data_conduit import UnkTableDataConduit
 
         if source is not None and isinstance(source, Sequence) and len(source) == 0:
-            raise excs.Error('Cannot insert an empty sequence')
+            raise excs.Error('Cannot insert an empty sequence.')
         fail_on_exception = OnErrorParameter.fail_on_exception(on_error)
 
         with Catalog.get().begin_xact(tbl=self._tbl_version_path, for_write=True, lock_mutable_tree=True):
@@ -214,7 +211,7 @@ class InsertableTable(Table):
             try:
                 pxt_rows.append(row.model_dump(mode='json'))
             except pydantic_core.PydanticSerializationError as e:
-                raise excs.Error(f'Row {i}: error serializing pydantic model to JSON:\n{e!s}') from e
+                raise excs.Error(f'Row {i}: error serializing pydantic model to JSON:\n{e}') from e
 
         # explicitly check that all required columns are present and non-None in the rows,
         # because we ignore nullability when validating the pydantic model
@@ -222,7 +219,7 @@ class InsertableTable(Table):
         for i, pxt_row in enumerate(pxt_rows):
             if type(rows[i]) is not model_class:
                 raise excs.Error(
-                    f'Expected {model_class.__name__!r} instance, got {type(rows[i]).__name__!r} (in row {i})'
+                    f'Expected an instance of `{model_class.__name__}`; got `{type(rows[i]).__name__}` (in row {i})'
                 )
             for col_name in reqd_col_names:
                 if pxt_row.get(col_name) is None:
@@ -253,22 +250,20 @@ class InsertableTable(Table):
         missing_required = required_cols - model_field_names
         if missing_required:
             raise excs.Error(
-                f'Pydantic model {model.__name__!r} is missing required columns: '
-                f'{", ".join(f"{col_name!r}" for col_name in missing_required)}'
+                f'Pydantic model `{model.__name__}` is missing required columns: ' + ', '.join(missing_required)
             )
 
         computed_in_model = computed_cols & model_field_names
         if computed_in_model:
             raise excs.Error(
-                f'Pydantic model {model.__name__!r} has fields for computed columns: '
-                f'{", ".join(f"{col_name!r}" for col_name in computed_in_model)}'
+                f'Pydantic model `{model.__name__}` has fields for computed columns: ' + ', '.join(computed_in_model)
             )
 
         # validate type compatibility
         common_fields = model_field_names & set(schema.keys())
         if len(common_fields) == 0:
             raise excs.Error(
-                f'Pydantic model {model.__name__!r} has no fields that map to columns in table {self._name!r}'
+                f'Pydantic model `{model.__name__}` has no fields that map to columns in table {self._name!r}'
             )
         for field_name in common_fields:
             pxt_col_type = schema[field_name]
@@ -281,21 +276,21 @@ class InsertableTable(Table):
             inferred_pxt_type = ts.ColumnType.from_python_type(model_type, infer_pydantic_json=True)
             if inferred_pxt_type is None:
                 raise excs.Error(
-                    f'Pydantic model {model.__name__!r}: cannot infer Pixeltable type for column {field_name!r}'
+                    f'Pydantic model `{model.__name__}`: cannot infer Pixeltable type for column {field_name!r}'
                 )
 
             if pxt_col_type.is_media_type():
                 # media types require file paths, either as str or Path
                 if not inferred_pxt_type.is_string_type():
                     raise excs.Error(
-                        f"Column {field_name!r} requires a 'str' or 'Path' field in {model.__name__!r}, but it is "
-                        f'{model_type.__name__!r}'
+                        f'Column {field_name!r} requires a `str` or `Path` field in `{model.__name__}`, but it is '
+                        f'`{model_type.__name__}`'
                     )
             else:
                 if not pxt_col_type.is_supertype_of(inferred_pxt_type, ignore_nullable=True):
                     raise excs.Error(
-                        f'Pydantic model {model.__name__!r} has incompatible type ({model_type.__name__}) '
-                        f'for column {field_name!r} ({pxt_col_type})'
+                        f'Pydantic model `{model.__name__}` has incompatible type `{model_type.__name__}` '
+                        f'for column {field_name!r} (of Pixeltable type `{pxt_col_type}`)'
                     )
 
                 if (
@@ -304,11 +299,11 @@ class InsertableTable(Table):
                     and not is_json_convertible(model_type)
                 ):
                     raise excs.Error(
-                        f'Pydantic model {model.__name__!r} has field {field_name!r} with nested model '
-                        f'{model_type.__name__!r}, which is not JSON-convertible'
+                        f'Pydantic model `{model.__name__}` has field {field_name!r} with nested model '
+                        f'`{model_type.__name__}`, which is not JSON-convertible'
                     )
 
-    def delete(self, where: Optional['exprs.Expr'] = None) -> UpdateStatus:
+    def delete(self, where: 'exprs.Expr' | None = None) -> UpdateStatus:
         """Delete rows in this table.
 
         Args:
@@ -328,11 +323,11 @@ class InsertableTable(Table):
         with Catalog.get().begin_xact(tbl=self._tbl_version_path, for_write=True, lock_mutable_tree=True):
             return self._tbl_version.get().delete(where=where)
 
-    def _get_base_table(self) -> Optional['Table']:
+    def _get_base_table(self) -> 'Table' | None:
         return None
 
     @property
-    def _effective_base_versions(self) -> list[Optional[int]]:
+    def _effective_base_versions(self) -> list[int | None]:
         return []
 
     def _table_descriptor(self) -> str:

pixeltable/catalog/path.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 from pixeltable import exceptions as excs
 
@@ -12,9 +11,9 @@ _logger = logging.getLogger('pixeltable')
 
 class Path:
     components: list[str]
-    version: Optional[int]
+    version: int | None
 
-    def __init__(self, components: list[str], version: Optional[int] = None) -> None:
+    def __init__(self, components: list[str], version: int | None = None) -> None:
         assert len(components) > 0
         self.components = components
         self.version = version
@@ -28,7 +27,7 @@ class Path:
         allow_versioned_path: bool = False,
     ) -> Path:
         components: list[str]
-        version: Optional[int]
+        version: int | None
         if ':' in path:
             parts = path.split(':')
             if len(parts) != 2:

pixeltable/catalog/schema_object.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 from uuid import UUID
 
 if TYPE_CHECKING:
@@ -14,16 +14,16 @@ class SchemaObject:
 
     _id: UUID
     _name: str
-    _dir_id: Optional[UUID]
+    _dir_id: UUID | None
 
-    def __init__(self, obj_id: UUID, name: str, dir_id: Optional[UUID]):
+    def __init__(self, obj_id: UUID, name: str, dir_id: UUID | None):
         # make these private so they don't collide with column names (id and name are fairly common)
         assert dir_id is None or isinstance(dir_id, UUID), type(dir_id)
         self._id = obj_id
         self._name = name
         self._dir_id = dir_id
 
-    def _parent(self) -> Optional['catalog.Dir']:
+    def _parent(self) -> 'catalog.Dir | None':
         """Returns the parent directory of this schema object."""
         from .catalog import Catalog