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

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)

pixeltable/io/fiftyone.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any, Iterator, Optional
+from typing import Any, Iterator
 
 import fiftyone as fo  # type: ignore[import-untyped]
 import fiftyone.utils.data as foud  # type: ignore[import-untyped]
@@ -20,7 +20,7 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
     __image_format: str  # format to use for any exported images that are not already stored on disk
     __labels: dict[str, tuple[exprs.Expr, type[fo.Label]]]  # label_name -> (expr, label_cls)
     __image_idx: int  # index of the image expr in the select list
-    __localpath_idx: Optional[int]  # index of the image localpath in the select list, if present
+    __localpath_idx: int | None  # index of the image localpath in the select list, if present
     __row_iter: Iterator[list]  # iterator over the table rows, to be convered to FiftyOne samples
 
     def __init__(
@@ -30,10 +30,10 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
         image_format: str,
         classifications: exprs.Expr | list[exprs.Expr] | dict[str, exprs.Expr] | None = None,
         detections: exprs.Expr | list[exprs.Expr] | dict[str, exprs.Expr] | None = None,
-        dataset_dir: Optional[os.PathLike] = None,
+        dataset_dir: os.PathLike | None = None,
         shuffle: bool = False,
         seed: int | float | str | bytes | bytearray | None = None,
-        max_samples: Optional[int] = None,
+        max_samples: int | None = None,
     ):
         super().__init__(dataset_dir=dataset_dir, shuffle=shuffle, seed=seed, max_samples=max_samples)
 
@@ -90,7 +90,7 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
         df = tbl.select(*selection)
         self.__row_iter = df._output_row_iterator()
 
-    def __next__(self) -> tuple[str, Optional[fo.ImageMetadata], Optional[dict[str, fo.Label]]]:
+    def __next__(self) -> tuple[str, fo.ImageMetadata | None, dict[str, fo.Label] | None]:
         row = next(self.__row_iter)
         img = row[self.__image_idx]
         assert isinstance(img, PIL.Image.Image)

pixeltable/io/globals.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
@@ -15,12 +15,12 @@ if TYPE_CHECKING:
 def create_label_studio_project(
     t: Table,
     label_config: str,
-    name: Optional[str] = None,
-    title: Optional[str] = None,
+    name: str | None = None,
+    title: str | None = None,
     media_import_method: Literal['post', 'file', 'url'] = 'post',
-    col_mapping: Optional[dict[str, str]] = None,
+    col_mapping: dict[str, str] | None = None,
     sync_immediately: bool = True,
-    s3_configuration: Optional[dict[str, Any]] = None,
+    s3_configuration: dict[str, Any] | None = None,
     **kwargs: Any,
 ) -> UpdateStatus:
     """

pixeltable/io/hf_datasets.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import typing
-from typing import Any, Optional
+from typing import Any
 
 import pixeltable as pxt
 import pixeltable.type_system as ts
@@ -36,7 +36,7 @@ _hf_to_pxt: dict[str, ts.ColumnType] = {
 }
 
 
-def _to_pixeltable_type(feature_type: Any, nullable: bool) -> Optional[ts.ColumnType]:
+def _to_pixeltable_type(feature_type: Any, nullable: bool) -> ts.ColumnType | None:
     """Convert a huggingface feature type to a pixeltable ColumnType if one is defined."""
     import datasets
 
@@ -76,7 +76,7 @@ def _get_hf_schema(dataset: datasets.Dataset | datasets.DatasetDict) -> datasets
 
 def huggingface_schema_to_pxt_schema(
     hf_schema: datasets.Features, schema_overrides: dict[str, Any], primary_key: list[str]
-) -> dict[str, Optional[ts.ColumnType]]:
+) -> dict[str, ts.ColumnType | None]:
     """Generate a pixeltable schema from a huggingface dataset schema.
     Columns without a known mapping are mapped to None
     """
@@ -93,7 +93,7 @@ def import_huggingface_dataset(
     table_path: str,
     dataset: datasets.Dataset | datasets.DatasetDict,
     *,
-    schema_overrides: Optional[dict[str, Any]] = None,
+    schema_overrides: dict[str, Any] | None = None,
     primary_key: str | list[str] | None = None,
     **kwargs: Any,
 ) -> pxt.Table:

pixeltable/io/label_studio.py

@@ -4,7 +4,7 @@ import logging
 import os
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Iterator, Literal, Optional
+from typing import Any, Iterator, Literal
 from xml.etree import ElementTree as ET
 
 import label_studio_sdk
@@ -53,7 +53,7 @@ class LabelStudioProject(Project):
 
     project_id: int  # Label Studio project ID
     media_import_method: Literal['post', 'file', 'url']
-    _project: Optional[ls_project.Project]
+    _project: ls_project.Project | None
 
     def __init__(
         self,
@@ -61,7 +61,7 @@ class LabelStudioProject(Project):
         project_id: int,
         media_import_method: Literal['post', 'file', 'url'],
         col_mapping: dict[ColumnHandle, str],
-        stored_proxies: Optional[dict[ColumnHandle, ColumnHandle]] = None,
+        stored_proxies: dict[ColumnHandle, ColumnHandle] | None = None,
     ):
         self.project_id = project_id
         self.media_import_method = media_import_method
@@ -278,8 +278,8 @@ class LabelStudioProject(Project):
         # columns. `rl_col_idxs` holds the indices for the columns that map to RectangleLabels
         # preannotations; `data_col_idxs` holds the indices for the columns that map to data fields.
         # We have to wait until we begin iterating to populate them, so they're initially `None`.
-        rl_col_idxs: Optional[list[int]] = None
-        data_col_idxs: Optional[list[int]] = None
+        rl_col_idxs: list[int] | None = None
+        data_col_idxs: list[int] | None = None
 
         row_ids_in_pxt: set[tuple] = set()
         tasks_created = 0
@@ -349,7 +349,7 @@ class LabelStudioProject(Project):
         return sync_status
 
     @classmethod
-    def __validate_fileurl(cls, col: Column, url: str) -> Optional[str]:
+    def __validate_fileurl(cls, col: Column, url: str) -> str | None:
         # Check that the URL is one that will be visible to Label Studio. If it isn't, log an info message
         # to help users debug the issue.
         if not (url.startswith('http://') or url.startswith('https://')):
@@ -497,7 +497,7 @@ class LabelStudioProject(Project):
 
     @classmethod
     def __coco_to_predictions(
-        cls, coco_annotations: dict[str, Any], from_name: str, rl_info: '_RectangleLabel', task_id: Optional[int] = None
+        cls, coco_annotations: dict[str, Any], from_name: str, rl_info: '_RectangleLabel', task_id: int | None = None
     ) -> dict[str, Any]:
         width = coco_annotations['image']['width']
         height = coco_annotations['image']['height']
@@ -549,11 +549,11 @@ class LabelStudioProject(Project):
         cls,
         t: Table,
         label_config: str,
-        name: Optional[str],
-        title: Optional[str],
+        name: str | None,
+        title: str | None,
         media_import_method: Literal['post', 'file', 'url'],
-        col_mapping: Optional[dict[str, str]],
-        s3_configuration: Optional[dict[str, Any]],
+        col_mapping: dict[str, str] | None,
+        s3_configuration: dict[str, Any] | None,
         **kwargs: Any,
     ) -> 'LabelStudioProject':
         """
@@ -652,7 +652,7 @@ class LabelStudioProject(Project):
 
 @dataclass(frozen=True)
 class _DataKey:
-    name: Optional[str]  # The 'name' attribute of the data key; may differ from the field name
+    name: str | None  # The 'name' attribute of the data key; may differ from the field name
     column_type: ts.ColumnType
 
 

pixeltable/io/pandas.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any, Optional
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -16,7 +16,7 @@ def import_pandas(
     tbl_name: str,
     df: pd.DataFrame,
     *,
-    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 = '',
@@ -56,7 +56,7 @@ def import_pandas(
 def import_csv(
     tbl_name: str,
     filepath_or_buffer: str | os.PathLike,
-    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 = '',
@@ -86,7 +86,7 @@ def import_excel(
     tbl_name: str,
     io: str | os.PathLike,
     *,
-    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 = '',
@@ -141,7 +141,7 @@ def df_infer_schema(
     return pd_schema
 
 
-def __pd_dtype_to_pxt_type(pd_dtype: DtypeObj, nullable: bool) -> Optional[ts.ColumnType]:
+def __pd_dtype_to_pxt_type(pd_dtype: DtypeObj, nullable: bool) -> ts.ColumnType | None:
     """
     Determines a pixeltable ColumnType from a pandas dtype
 
@@ -192,7 +192,7 @@ def __pd_coltype_to_pxt_type(pd_dtype: DtypeObj, data_col: pd.Series, nullable:
 
 
 def _df_row_to_pxt_row(
-    row: tuple[Any, ...], schema: dict[str, ts.ColumnType], col_mapping: Optional[dict[str, str]]
+    row: tuple[Any, ...], schema: dict[str, ts.ColumnType], col_mapping: dict[str, str] | None
 ) -> dict[str, Any]:
     """Convert a row to insertable format"""
     pxt_row: dict[str, Any] = {}

pixeltable/io/parquet.py

@@ -4,7 +4,7 @@ import json
 import logging
 import typing
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
@@ -71,7 +71,7 @@ def import_parquet(
     table: str,
     *,
     parquet_path: str,
-    schema_overrides: Optional[dict[str, Any]] = None,
+    schema_overrides: dict[str, Any] | None = None,
     primary_key: str | list[str] | None = None,
     **kwargs: Any,
 ) -> pxt.Table: