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

pixeltable/globals.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import os
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Iterable, Literal, NamedTuple, Optional, Union
+from typing import TYPE_CHECKING, Any, Iterable, Literal, NamedTuple, Union
 
 import pandas as pd
 import pydantic
@@ -14,6 +14,7 @@ from pixeltable.catalog import Catalog, TableVersionPath
 from pixeltable.catalog.insertable_table import OnErrorParameter
 from pixeltable.config import Config
 from pixeltable.env import Env
+from pixeltable.io.table_data_conduit import DFTableDataConduit, TableDataConduit
 from pixeltable.iterators import ComponentIterator
 
 if TYPE_CHECKING:
@@ -36,7 +37,7 @@ if TYPE_CHECKING:
 _logger = logging.getLogger('pixeltable')
 
 
-def init(config_overrides: Optional[dict[str, Any]] = None) -> None:
+def init(config_overrides: dict[str, Any] | None = None) -> None:
     """Initializes the Pixeltable environment."""
     if config_overrides is None:
         config_overrides = {}
@@ -46,18 +47,19 @@ def init(config_overrides: Optional[dict[str, Any]] = None) -> None:
 
 def create_table(
     path: str,
-    schema: Optional[dict[str, Any]] = None,
+    schema: dict[str, Any] | None = None,
     *,
-    source: Optional[TableDataSource] = None,
-    source_format: Optional[Literal['csv', 'excel', 'parquet', 'json']] = None,
-    schema_overrides: Optional[dict[str, Any]] = None,
+    source: TableDataSource | None = None,
+    source_format: Literal['csv', 'excel', 'parquet', 'json'] | None = None,
+    schema_overrides: dict[str, Any] | None = None,
+    create_default_idxs: bool = True,
     on_error: Literal['abort', 'ignore'] = 'abort',
     primary_key: str | list[str] | None = None,
     num_retained_versions: int = 10,
     comment: str = '',
     media_validation: Literal['on_read', 'on_write'] = 'on_write',
     if_exists: Literal['error', 'ignore', 'replace', 'replace_force'] = 'error',
-    extra_args: Optional[dict[str, Any]] = None,  # Additional arguments to data source provider
+    extra_args: dict[str, Any] | None = None,  # Additional arguments to data source provider
 ) -> catalog.Table:
     """Create a new base table. Exactly one of `schema` or `source` must be provided.
 
@@ -77,6 +79,8 @@ def create_table(
         schema_overrides: Must be used in conjunction with a `source`.
             If specified, then columns in `schema_overrides` will be given the specified types.
             (Pixeltable will attempt to infer the types of any columns not specified.)
+        create_default_idxs: If True, creates a B-tree index on every scalar and media column that is not computed,
+            except for boolean columns.
         on_error: Determines the behavior if an error occurs while evaluating a computed column or detecting an
             invalid media file (such as a corrupt image) for one of the inserted rows.
 
@@ -138,7 +142,7 @@ def create_table(
 
         >>> tbl = pxt.create_table('my_table', source='data.csv')
     """
-    from pixeltable.io.table_data_conduit import DFTableDataConduit, UnkTableDataConduit
+    from pixeltable.io.table_data_conduit import UnkTableDataConduit
     from pixeltable.io.utils import normalize_primary_key_parameter
 
     if (schema is None) == (source is None):
@@ -150,11 +154,16 @@ def create_table(
     path_obj = catalog.Path.parse(path)
     if_exists_ = catalog.IfExistsParam.validated(if_exists, 'if_exists')
     media_validation_ = catalog.MediaValidation.validated(media_validation, 'media_validation')
-    primary_key: Optional[list[str]] = normalize_primary_key_parameter(primary_key)
-    table: catalog.Table = None
-    tds = None
-    data_source = None
+    primary_key: list[str] | None = normalize_primary_key_parameter(primary_key)
+    data_source: TableDataConduit | None = None
     if source is not None:
+        if isinstance(source, str) and source.strip().startswith('pxt://'):
+            raise excs.Error(
+                'create_table(): Creating a table directly from a cloud URI is not supported.'
+                ' Please replicate the table locally first using `pxt.replicate()`:\n'
+                "replica_tbl = pxt.replicate('pxt://path/to/remote_table', 'local_replica_name')\n"
+                "pxt.create_table('new_table_name', source=replica_tbl)"
+            )
         tds = UnkTableDataConduit(source, source_format=source_format, extra_fields=extra_args)
         tds.check_source_format()
         data_source = tds.specialize()
@@ -179,35 +188,43 @@ def create_table(
             'Unable to create a proper schema from supplied `source`. Please use appropriate `schema_overrides`.'
         )
 
-    table, was_created = Catalog.get().create_table(
+    tbl, was_created = Catalog.get().create_table(
         path_obj,
         schema,
-        data_source.pxt_df if isinstance(data_source, DFTableDataConduit) else None,
         if_exists=if_exists_,
         primary_key=primary_key,
         comment=comment,
         media_validation=media_validation_,
         num_retained_versions=num_retained_versions,
+        create_default_idxs=create_default_idxs,
     )
-    if was_created and data_source is not None and not is_direct_df:
+
+    # TODO: combine data loading with table creation into a single transaction
+    if was_created:
         fail_on_exception = OnErrorParameter.fail_on_exception(on_error)
-        table.insert_table_data_source(data_source=data_source, fail_on_exception=fail_on_exception)
+        if isinstance(data_source, DFTableDataConduit):
+            df = data_source.pxt_df
+            with Catalog.get().begin_xact(tbl=tbl._tbl_version_path, for_write=True, lock_mutable_tree=True):
+                tbl._tbl_version.get().insert(None, df, fail_on_exception=fail_on_exception)
+        elif data_source is not None and not is_direct_df:
+            tbl.insert_table_data_source(data_source=data_source, fail_on_exception=fail_on_exception)
 
-    return table
+    return tbl
 
 
 def create_view(
     path: str,
     base: catalog.Table | DataFrame,
     *,
-    additional_columns: Optional[dict[str, Any]] = None,
+    additional_columns: dict[str, Any] | None = None,
     is_snapshot: bool = False,
-    iterator: Optional[tuple[type[ComponentIterator], dict[str, Any]]] = None,
+    create_default_idxs: bool = False,
+    iterator: tuple[type[ComponentIterator], dict[str, Any]] | None = None,
     num_retained_versions: int = 10,
     comment: str = '',
     media_validation: Literal['on_read', 'on_write'] = 'on_write',
     if_exists: Literal['error', 'ignore', 'replace', 'replace_force'] = 'error',
-) -> Optional[catalog.Table]:
+) -> catalog.Table | None:
     """Create a view of an existing table object (which itself can be a view or a snapshot or a base table).
 
     Args:
@@ -220,6 +237,8 @@ def create_view(
             [`create_table`][pixeltable.create_table].
         is_snapshot: Whether the view is a snapshot. Setting this to `True` is equivalent to calling
             [`create_snapshot`][pixeltable.create_snapshot].
+        create_default_idxs: Whether to create default indexes on the view's columns (the base's columns are excluded).
+            Cannot be `True` for snapshots.
         iterator: The iterator to use for this view. If specified, then this view will be a one-to-many view of
             the base table.
         num_retained_versions: Number of versions of the view to retain.
@@ -267,9 +286,11 @@ def create_view(
         >>> tbl = pxt.get_table('my_table')
         ... view = pxt.create_view('my_view', tbl.where(tbl.col1 > 100), if_exists='replace_force')
     """
+    if is_snapshot and create_default_idxs is True:
+        raise excs.Error('Cannot create default indexes on a snapshot')
     tbl_version_path: TableVersionPath
-    select_list: Optional[list[tuple[exprs.Expr, Optional[str]]]] = None
-    where: Optional[exprs.Expr] = None
+    select_list: list[tuple[exprs.Expr, str | None]] | None = None
+    where: exprs.Expr | None = None
     if isinstance(base, catalog.Table):
         tbl_version_path = base._tbl_version_path
         sample_clause = None
@@ -297,7 +318,7 @@ def create_view(
             if col_name in [c.name for c in tbl_version_path.columns()]:
                 raise excs.Error(
                     f'Column {col_name!r} already exists in the base table '
-                    f'{tbl_version_path.get_column(col_name).tbl.name}.'
+                    f'{tbl_version_path.get_column(col_name).get_tbl().name}.'
                 )
 
     return Catalog.get().create_view(
@@ -308,6 +329,7 @@ def create_view(
         sample_clause=sample_clause,
         additional_columns=additional_columns,
         is_snapshot=is_snapshot,
+        create_default_idxs=create_default_idxs,
         iterator=iterator,
         num_retained_versions=num_retained_versions,
         comment=comment,
@@ -320,13 +342,13 @@ def create_snapshot(
     path_str: str,
     base: catalog.Table | DataFrame,
     *,
-    additional_columns: Optional[dict[str, Any]] = None,
-    iterator: Optional[tuple[type[ComponentIterator], dict[str, Any]]] = None,
+    additional_columns: dict[str, Any] | None = None,
+    iterator: tuple[type[ComponentIterator], dict[str, Any]] | None = None,
     num_retained_versions: int = 10,
     comment: str = '',
     media_validation: Literal['on_read', 'on_write'] = 'on_write',
     if_exists: Literal['error', 'ignore', 'replace', 'replace_force'] = 'error',
-) -> Optional[catalog.Table]:
+) -> catalog.Table | None:
     """Create a snapshot of an existing table object (which itself can be a view or a snapshot or a base table).
 
     Args:
@@ -680,7 +702,7 @@ def _list_tables(dir_path: str = '', recursive: bool = True, allow_system_paths:
 
 def create_dir(
     path: str, *, if_exists: Literal['error', 'ignore', 'replace', 'replace_force'] = 'error', parents: bool = False
-) -> Optional[catalog.Dir]:
+) -> catalog.Dir | None:
     """Create a directory.
 
     Args:
@@ -835,9 +857,7 @@ def ls(path: str = '') -> pd.DataFrame:
 
 
 def _extract_paths(
-    dir_entries: dict[str, Catalog.DirEntry],
-    parent: catalog.Path,
-    entry_type: Optional[type[catalog.SchemaObject]] = None,
+    dir_entries: dict[str, Catalog.DirEntry], parent: catalog.Path, entry_type: type[catalog.SchemaObject] | None = None
 ) -> list[catalog.Path]:
     """Convert nested dir_entries structure to a flattened list of paths."""
     matches: list[str]
@@ -947,7 +967,7 @@ def tools(*args: func.Function | func.tools.Tool) -> func.tools.Tools:
     return func.tools.Tools(tools=[arg if isinstance(arg, func.tools.Tool) else tool(arg) for arg in args])
 
 
-def tool(fn: func.Function, name: Optional[str] = None, description: Optional[str] = None) -> func.tools.Tool:
+def tool(fn: func.Function, name: str | None = None, description: str | None = None) -> func.tools.Tool:
     """
     Specifies a Pixeltable UDF to be used as an LLM tool with customizable metadata. See the documentation for
     [pxt.tools()][pixeltable.tools] for more details.
@@ -968,11 +988,7 @@ def tool(fn: func.Function, name: Optional[str] = None, description: Optional[st
 
 
 def configure_logging(
-    *,
-    to_stdout: Optional[bool] = None,
-    level: Optional[int] = None,
-    add: Optional[str] = None,
-    remove: Optional[str] = None,
+    *, to_stdout: bool | None = None, level: int | None = None, add: str | None = None, remove: str | None = None
 ) -> None:
     """Configure logging.
 

pixeltable/index/base.py

@@ -5,7 +5,9 @@ from typing import Any
 
 import sqlalchemy as sql
 
-from pixeltable import catalog, exprs
+import pixeltable.catalog as catalog
+import pixeltable.exprs as exprs
+import pixeltable.type_system as ts
 
 
 class IndexBase(abc.ABC):
@@ -18,12 +20,14 @@ class IndexBase(abc.ABC):
     """
 
     @abc.abstractmethod
-    def __init__(self, c: catalog.Column, **kwargs: Any):
+    def __init__(self, **kwargs: Any):
         pass
 
     @abc.abstractmethod
-    def index_value_expr(self) -> exprs.Expr:
-        """Return expression that computes the value that goes into the index"""
+    def create_value_expr(self, c: catalog.Column) -> exprs.Expr:
+        """
+        Validates that the index can be created on column c and returns an expression that computes the index value.
+        """
         pass
 
     @abc.abstractmethod
@@ -32,13 +36,13 @@ class IndexBase(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def index_sa_type(self) -> sql.types.TypeEngine:
+    def get_index_sa_type(self, value_col_type: ts.ColumnType) -> sql.types.TypeEngine:
         """Return the sqlalchemy type of the index value column"""
         pass
 
     @abc.abstractmethod
-    def create_index(self, index_name: str, index_value_col: catalog.Column) -> None:
-        """Create the index on the index value column"""
+    def sa_index(self, index_name: str, index_value_col: catalog.Column) -> sql.Index:
+        """Return a sqlalchemy Index instance"""
         pass
 
     @abc.abstractmethod
@@ -57,5 +61,5 @@ class IndexBase(abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    def from_dict(cls, c: catalog.Column, d: dict) -> IndexBase:
+    def from_dict(cls, d: dict) -> IndexBase:
         pass

pixeltable/index/btree.py

@@ -1,18 +1,18 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import sqlalchemy as sql
 
 # TODO: why does this import result in a circular import, but the one im embedding_index.py doesn't?
 # import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
-from pixeltable import catalog, exprs
-from pixeltable.env import Env
+import pixeltable.exprs as exprs
+import pixeltable.type_system as ts
 from pixeltable.func.udf import udf
 
 from .base import IndexBase
 
 if TYPE_CHECKING:
-    import pixeltable.exprs
+    import pixeltable.catalog as catalog
 
 
 class BtreeIndex(IndexBase):
@@ -22,42 +22,39 @@ class BtreeIndex(IndexBase):
 
     MAX_STRING_LEN = 256
 
-    value_expr: 'pixeltable.exprs.Expr'
-
     @staticmethod
     @udf
-    def str_filter(s: Optional[str]) -> Optional[str]:
+    def str_filter(s: str | None) -> str | None:
         if s is None:
             return None
         return s[: BtreeIndex.MAX_STRING_LEN]
 
-    def __init__(self, c: 'catalog.Column'):
+    def __init__(self) -> None:
+        pass
+
+    def create_value_expr(self, c: 'catalog.Column') -> 'exprs.Expr':
         if not c.col_type.is_scalar_type() and not c.col_type.is_media_type():
             raise excs.Error(f'Index on column {c.name}: B-tree index requires scalar or media type, got {c.col_type}')
+        value_expr: exprs.Expr
         if c.col_type.is_media_type():
             # an index on a media column is an index on the file url
             # no validation for media columns: we're only interested in the string value
-            self.value_expr = exprs.ColumnRef(c, perform_validation=False)
+            value_expr = exprs.ColumnRef(c, perform_validation=False)
         else:
-            self.value_expr = (
+            value_expr = (
                 BtreeIndex.str_filter(exprs.ColumnRef(c)) if c.col_type.is_string_type() else exprs.ColumnRef(c)
             )
-
-    def index_value_expr(self) -> 'exprs.Expr':
-        return self.value_expr
+        return value_expr
 
     def records_value_errors(self) -> bool:
         return False
 
-    def index_sa_type(self) -> sql.types.TypeEngine:
+    def get_index_sa_type(self, val_col_type: ts.ColumnType) -> sql.types.TypeEngine:
         """Return the sqlalchemy type of the index value column"""
-        return self.value_expr.col_type.to_sa_type()
+        return val_col_type.to_sa_type()
 
-    def create_index(self, index_name: str, index_value_col: 'catalog.Column') -> None:
-        """Create the index on the index value column"""
-        idx = sql.Index(index_name, index_value_col.sa_col, postgresql_using='btree')
-        conn = Env.get().conn
-        idx.create(bind=conn)
+    def sa_index(self, store_index_name: str, index_value_col: 'catalog.Column') -> sql.Index:
+        return sql.Index(store_index_name, index_value_col.sa_col, postgresql_using='btree')
 
     def drop_index(self, index_name: str, index_value_col: 'catalog.Column') -> None:
         """Drop the index on the index value column"""
@@ -72,5 +69,5 @@ class BtreeIndex(IndexBase):
         return {}
 
     @classmethod
-    def from_dict(cls, c: 'catalog.Column', d: dict) -> 'BtreeIndex':
-        return cls(c)
+    def from_dict(cls, d: dict) -> 'BtreeIndex':
+        return cls()

pixeltable/index/embedding_index.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
 
 import enum
-from typing import Any, ClassVar, Optional
+from typing import Any, ClassVar
 
 import numpy as np
 import pgvector.sqlalchemy  # type: ignore[import-untyped]
 import PIL.Image
 import sqlalchemy as sql
 
+import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
+import pixeltable.exprs as exprs
+import pixeltable.func as func
 import pixeltable.type_system as ts
-from pixeltable import catalog, exprs, func
 from pixeltable.env import Env
 
 from .base import IndexBase
@@ -39,28 +41,23 @@ class EmbeddingIndex(IndexBase):
     }
 
     metric: Metric
-    value_expr: exprs.FunctionCall
-    string_embed: Optional[func.Function]
-    image_embed: Optional[func.Function]
+    string_embed: func.Function | None
+    image_embed: func.Function | None
     string_embed_signature_idx: int
     image_embed_signature_idx: int
-    index_col_type: pgvector.sqlalchemy.Vector
 
     def __init__(
         self,
-        c: catalog.Column,
         metric: str,
-        embed: Optional[func.Function] = None,
-        string_embed: Optional[func.Function] = None,
-        image_embed: Optional[func.Function] = None,
+        embed: func.Function | None = None,
+        string_embed: func.Function | None = None,
+        image_embed: func.Function | None = None,
     ):
         if embed is None and string_embed is None and image_embed is None:
             raise excs.Error('At least one of `embed`, `string_embed`, or `image_embed` must be specified')
         metric_names = [m.name.lower() for m in self.Metric]
         if metric.lower() not in metric_names:
             raise excs.Error(f'Invalid metric {metric}, must be one of {metric_names}')
-        if not c.col_type.is_string_type() and not c.col_type.is_image_type():
-            raise excs.Error('Embedding index requires string or image column')
 
         self.string_embed = None
         self.image_embed = None
@@ -102,47 +99,42 @@ class EmbeddingIndex(IndexBase):
             )
 
         # Now validate the return types of the embedding functions.
-
         if self.string_embed is not None:
             self._validate_embedding_fn(self.string_embed)
-
         if self.image_embed is not None:
             self._validate_embedding_fn(self.image_embed)
 
+        self.metric = self.Metric[metric.upper()]
+
+    def create_value_expr(self, c: catalog.Column) -> exprs.Expr:
+        if not c.col_type.is_string_type() and not c.col_type.is_image_type():
+            raise excs.Error(
+                f'Embedding index requires string or image column, column {c.name!r} has type {c.col_type}'
+            )
         if c.col_type.is_string_type() and self.string_embed is None:
             raise excs.Error(f"Text embedding function is required for column {c.name} (parameter 'string_embed')")
         if c.col_type.is_image_type() and self.image_embed is None:
             raise excs.Error(f"Image embedding function is required for column {c.name} (parameter 'image_embed')")
 
-        self.metric = self.Metric[metric.upper()]
-        self.value_expr = (
+        return (
             self.string_embed(exprs.ColumnRef(c))
             if c.col_type.is_string_type()
             else self.image_embed(exprs.ColumnRef(c))
         )
-        assert isinstance(self.value_expr.col_type, ts.ArrayType)
-        vector_size = self.value_expr.col_type.shape[0]
-        assert vector_size is not None
-        self.index_col_type = pgvector.sqlalchemy.Vector(vector_size)
-
-    def index_value_expr(self) -> exprs.Expr:
-        """Return expression that computes the value that goes into the index"""
-        return self.value_expr
 
     def records_value_errors(self) -> bool:
         return True
 
-    def index_sa_type(self) -> sql.types.TypeEngine:
-        """Return the sqlalchemy type of the index value column"""
-        return self.index_col_type
+    def get_index_sa_type(self, val_col_type: ts.ColumnType) -> sql.types.TypeEngine:
+        assert isinstance(val_col_type, ts.ArrayType) and val_col_type.shape is not None
+        vector_size = val_col_type.shape[0]
+        assert vector_size is not None
+        return pgvector.sqlalchemy.Vector(vector_size)
 
-    def create_index(self, index_name: str, index_value_col: catalog.Column) -> None:
+    def sa_index(self, store_index_name: str, index_value_col: 'catalog.Column') -> sql.Index:
         """Create the index on the index value column"""
-        Env.get().dbms.create_vector_index(
-            index_name=index_name,
-            index_value_sa_col=index_value_col.sa_col,
-            conn=Env.get().conn,
-            metric=self.PGVECTOR_OPS[self.metric],
+        return Env.get().dbms.sa_vector_index(
+            store_index_name, index_value_col.sa_col, metric=self.PGVECTOR_OPS[self.metric]
         )
 
     def drop_index(self, index_name: str, index_value_col: catalog.Column) -> None:
@@ -153,6 +145,7 @@ class EmbeddingIndex(IndexBase):
     def similarity_clause(self, val_column: catalog.Column, item: Any) -> sql.ColumnElement:
         """Create a ColumnElement that represents '<val_column> <op> <item>'"""
         assert isinstance(item, (str, PIL.Image.Image))
+        embedding: np.ndarray
         if isinstance(item, str):
             assert self.string_embed is not None
             embedding = self.string_embed.exec([item], {})
@@ -171,7 +164,7 @@ class EmbeddingIndex(IndexBase):
     def order_by_clause(self, val_column: catalog.Column, item: Any, is_asc: bool) -> sql.ColumnElement:
         """Create a ColumnElement that is used in an ORDER BY clause"""
         assert isinstance(item, (str, PIL.Image.Image))
-        embedding: Optional[np.ndarray] = None
+        embedding: np.ndarray | None = None
         if isinstance(item, str):
             assert self.string_embed is not None
             embedding = self.string_embed.exec([item], {})
@@ -196,9 +189,7 @@ class EmbeddingIndex(IndexBase):
         return 'embedding'
 
     @classmethod
-    def _resolve_embedding_fn(
-        cls, embed_fn: func.Function, expected_type: ts.ColumnType.Type
-    ) -> Optional[func.Function]:
+    def _resolve_embedding_fn(cls, embed_fn: func.Function, expected_type: ts.ColumnType.Type) -> func.Function | None:
         """Find an overload resolution for `embed_fn` that matches the given type."""
         assert isinstance(embed_fn, func.Function)
         for resolved_fn in embed_fn._resolved_fns:
@@ -252,7 +243,7 @@ class EmbeddingIndex(IndexBase):
         }
 
     @classmethod
-    def from_dict(cls, c: catalog.Column, d: dict) -> EmbeddingIndex:
+    def from_dict(cls, d: dict) -> EmbeddingIndex:
         string_embed = func.Function.from_dict(d['string_embed']) if d['string_embed'] is not None else None
         image_embed = func.Function.from_dict(d['image_embed']) if d['image_embed'] is not None else None
-        return cls(c, metric=d['metric'], string_embed=string_embed, image_embed=image_embed)
+        return cls(metric=d['metric'], string_embed=string_embed, image_embed=image_embed)

pixeltable/io/datarows.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional
+from typing import Any, Iterable
 
 import pixeltable as pxt
 import pixeltable.type_system as ts
@@ -60,7 +60,7 @@ def import_rows(
     tbl_path: str,
     rows: list[dict[str, Any]],
     *,
-    schema_overrides: Optional[dict[str, Any]] = None,
+    schema_overrides: dict[str, Any] | None = None,
     primary_key: str | list[str] | None = None,
     num_retained_versions: int = 10,
     comment: str = '',
@@ -104,7 +104,7 @@ def import_json(
     tbl_path: str,
     filepath_or_url: str,
     *,
-    schema_overrides: Optional[dict[str, Any]] = None,
+    schema_overrides: dict[str, Any] | None = None,
     primary_key: str | list[str] | None = None,
     num_retained_versions: int = 10,
     comment: str = '',

pixeltable/io/external_store.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import abc
 import itertools
 import logging
-from typing import Any, Optional
+from typing import Any
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -68,10 +68,7 @@ class Project(ExternalStore, abc.ABC):
     stored_proxies: dict[ColumnHandle, ColumnHandle]  # original col -> proxy col
 
     def __init__(
-        self,
-        name: str,
-        col_mapping: dict[ColumnHandle, str],
-        stored_proxies: Optional[dict[ColumnHandle, ColumnHandle]],
+        self, name: str, col_mapping: dict[ColumnHandle, str], stored_proxies: dict[ColumnHandle, ColumnHandle] | None
     ):
         super().__init__(name)
         self._col_mapping = col_mapping
@@ -190,7 +187,7 @@ class Project(ExternalStore, abc.ABC):
         table: Table,
         export_cols: dict[str, ts.ColumnType],
         import_cols: dict[str, ts.ColumnType],
-        col_mapping: Optional[dict[str, str]],
+        col_mapping: dict[str, str] | None,
     ) -> dict[ColumnHandle, str]:
         """
         Verifies that the specified `col_mapping` is valid. In particular, checks that:
@@ -217,19 +214,19 @@ class Project(ExternalStore, abc.ABC):
             if t_col not in t_cols:
                 if is_user_specified_col_mapping:
                     raise excs.Error(
-                        f'Column name `{t_col}` appears as a key in `col_mapping`, but Table `{table._name}` '
+                        f'Column name {t_col!r} appears as a key in `col_mapping`, but {table._display_str()} '
                         'contains no such column.'
                     )
                 else:
                     raise excs.Error(
-                        f'Column `{t_col}` does not exist in Table `{table._name}`. Either add a column `{t_col}`, '
+                        f'Column {t_col!r} does not exist in {table._display_str()}. Either add a column {t_col!r}, '
                         f'or specify a `col_mapping` to associate a different column with '
-                        f'the external field `{ext_col}`.'
+                        f'the external field {ext_col!r}.'
                     )
             if ext_col not in export_cols and ext_col not in import_cols:
                 raise excs.Error(
-                    f'Column name `{ext_col}` appears as a value in `col_mapping`, but the external store '
-                    f'configuration has no column `{ext_col}`.'
+                    f'Column name {ext_col!r} appears as a value in `col_mapping`, but the external store '
+                    f'configuration has no column {ext_col!r}.'
                 )
             col_ref = table[t_col]
             assert isinstance(col_ref, exprs.ColumnRef)
@@ -244,19 +241,19 @@ class Project(ExternalStore, abc.ABC):
                 ext_col_type = export_cols[ext_col]
                 if not ext_col_type.is_supertype_of(t_col_type, ignore_nullable=True):
                     raise excs.Error(
-                        f'Column `{t_col}` cannot be exported to external column `{ext_col}` '
+                        f'Column {t_col!r} cannot be exported to external column {ext_col!r} '
                         f'(incompatible types; expecting `{ext_col_type}`)'
                     )
             if ext_col in import_cols:
                 # Validate that the external column can be assigned to the table column
                 if table._tbl_version_path.get_column(t_col).is_computed:
                     raise excs.Error(
-                        f'Column `{t_col}` is a computed column, which cannot be populated from an external column'
+                        f'Column {t_col!r} is a computed column, which cannot be populated from an external column'
                     )
                 ext_col_type = import_cols[ext_col]
                 if not t_col_type.is_supertype_of(ext_col_type, ignore_nullable=True):
                     raise excs.Error(
-                        f'Column `{t_col}` cannot be imported from external column `{ext_col}` '
+                        f'Column {t_col!r} cannot be imported from external column {ext_col!r} '
                         f'(incompatible types; expecting `{ext_col_type}`)'
                     )
         return resolved_col_mapping
@@ -271,7 +268,7 @@ class MockProject(Project):
         export_cols: dict[str, ts.ColumnType],
         import_cols: dict[str, ts.ColumnType],
         col_mapping: dict[ColumnHandle, str],
-        stored_proxies: Optional[dict[ColumnHandle, ColumnHandle]] = None,
+        stored_proxies: dict[ColumnHandle, ColumnHandle] | None = None,
     ):
         super().__init__(name, col_mapping, stored_proxies)
         self.export_cols = export_cols
@@ -285,7 +282,7 @@ class MockProject(Project):
         name: str,
         export_cols: dict[str, ts.ColumnType],
         import_cols: dict[str, ts.ColumnType],
-        col_mapping: Optional[dict[str, str]] = None,
+        col_mapping: dict[str, str] | None = None,
     ) -> 'MockProject':
         col_mapping = cls.validate_columns(t, export_cols, import_cols, col_mapping)
         return cls(name, export_cols, import_cols, col_mapping)