pixeltable 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

pixeltable/catalog/column.py

@@ -140,12 +140,12 @@ class Column:
                         The computed column {self.name!r} in table {self.tbl.get().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
                     )
                     .strip()
                     .format(validation_error=self._value_expr.validation_error)
                 )
-                warnings.warn(message, category=excs.PixeltableWarning)
+                warnings.warn(message, category=excs.PixeltableWarning, stacklevel=2)
         return self._value_expr
 
     def set_value_expr(self, value_expr: exprs.Expr) -> None:
@@ -165,8 +165,10 @@ class Column:
             return False
         from pixeltable import exprs
 
-        l = list(self.value_expr.subexprs(filter=lambda e: isinstance(e, exprs.FunctionCall) and e.is_window_fn_call))
-        return len(l) > 0
+        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
 
     def get_idx_info(self) -> dict[str, 'TableVersion.IndexInfo']:
         assert self.tbl is not None

pixeltable/catalog/dir.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
 import dataclasses
-import datetime
 import json
 import logging
 from uuid import UUID
 
 import sqlalchemy as sql
-from sqlalchemy.dialects.postgresql import JSONB
 
 from pixeltable.env import Env
 from pixeltable.metadata import schema
@@ -24,8 +22,9 @@ class Dir(SchemaObject):
     @classmethod
     def _create(cls, parent_id: UUID, name: str) -> Dir:
         session = Env.get().session
+        user = Env.get().user
         assert session is not None
-        dir_md = schema.DirMd(name=name, user=None, additional_md={})
+        dir_md = schema.DirMd(name=name, user=user, additional_md={})
         dir_record = schema.Dir(parent_id=parent_id, md=dataclasses.asdict(dir_md))
         session.add(dir_record)
         session.flush()
@@ -48,14 +47,15 @@ class Dir(SchemaObject):
 
     def _move(self, new_name: str, new_dir_id: UUID) -> None:
         # print(
-        #     f'{datetime.datetime.now()} move dir name={self._name} parent={self._dir_id} new_name={new_name} new_dir_id={new_dir_id}'
+        #     f'{datetime.datetime.now()} move dir name={self._name} parent={self._dir_id} '
+        #     f'new_name={new_name} new_dir_id={new_dir_id}'
         # )
         super()._move(new_name, new_dir_id)
         stmt = sql.text(
             (
                 f'UPDATE {schema.Dir.__table__} '
                 f'SET {schema.Dir.parent_id.name} = :new_dir_id, '
-                f"    {schema.Dir.md.name}['name'] = :new_name "
+                f"    {schema.Dir.md.name} = jsonb_set({schema.Dir.md.name}, '{{name}}', (:new_name)::jsonb) "
                 f'WHERE {schema.Dir.id.name} = :id'
             )
         )

pixeltable/catalog/globals.py

@@ -6,6 +6,8 @@ import itertools
 import logging
 from typing import Optional
 
+from typing_extensions import Self
+
 import pixeltable.exceptions as excs
 
 _logger = logging.getLogger('pixeltable')
@@ -32,7 +34,7 @@ class UpdateStatus:
     updated_cols: list[str] = dataclasses.field(default_factory=list)
     cols_with_excs: list[str] = dataclasses.field(default_factory=list)
 
-    def __iadd__(self, other: 'UpdateStatus') -> 'UpdateStatus':
+    def __iadd__(self, other: 'UpdateStatus') -> Self:
         self.num_rows += other.num_rows
         self.num_computed_values += other.num_computed_values
         self.num_excs += other.num_excs
@@ -66,8 +68,8 @@ class MediaValidation(enum.Enum):
         try:
             return cls[name.upper()]
         except KeyError:
-            val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__.keys())
-            raise excs.Error(f'{error_prefix} must be one of: [{val_strs}]')
+            val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__)
+            raise excs.Error(f'{error_prefix} must be one of: [{val_strs}]') from None
 
 
 class IfExistsParam(enum.Enum):
@@ -81,8 +83,8 @@ class IfExistsParam(enum.Enum):
         try:
             return cls[param_val.upper()]
         except KeyError:
-            val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__.keys())
-            raise excs.Error(f'{param_name} must be one of: [{val_strs}]')
+            val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__)
+            raise excs.Error(f'{param_name} must be one of: [{val_strs}]') from None
 
 
 class IfNotExistsParam(enum.Enum):
@@ -94,28 +96,24 @@ class IfNotExistsParam(enum.Enum):
         try:
             return cls[param_val.upper()]
         except KeyError:
-            val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__.keys())
-            raise excs.Error(f'{param_name} must be one of: [{val_strs}]')
+            val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__)
+            raise excs.Error(f'{param_name} must be one of: [{val_strs}]') from None
 
 
-def is_valid_identifier(name: str) -> bool:
-    return name.isidentifier() and not name.startswith('_')
+def is_valid_identifier(name: str, allow_system_identifiers: bool = False) -> bool:
+    return name.isidentifier() and (allow_system_identifiers or not name.startswith('_'))
 
 
-def is_valid_path(path: str, empty_is_valid: bool) -> bool:
+def is_valid_path(path: str, empty_is_valid: bool, allow_system_paths: bool = False) -> bool:
     if path == '':
         return empty_is_valid
-
-    for part in path.split('.'):
-        if not is_valid_identifier(part):
-            return False
-    return True
+    return all(is_valid_identifier(part, allow_system_paths) for part in path.split('.'))
 
 
 def is_system_column_name(name: str) -> bool:
     from pixeltable.catalog import InsertableTable, View
 
-    global _PREDEF_SYMBOLS
+    global _PREDEF_SYMBOLS  # noqa: PLW0603
     if _PREDEF_SYMBOLS is None:
         _PREDEF_SYMBOLS = set(itertools.chain(dir(InsertableTable), dir(View)))
     return name == _POS_COLUMN_NAME or name in _PREDEF_SYMBOLS

pixeltable/catalog/insertable_table.py

@@ -2,12 +2,11 @@ from __future__ import annotations
 
 import enum
 import logging
-from typing import TYPE_CHECKING, Any, Iterable, Literal, Optional, overload
+from typing import TYPE_CHECKING, Any, Literal, Optional, overload
 from uuid import UUID
 
 import pixeltable as pxt
-import pixeltable.type_system as ts
-from pixeltable import exceptions as excs
+from pixeltable import exceptions as excs, type_system as ts
 from pixeltable.env import Env
 from pixeltable.utils.filecache import FileCache
 
@@ -18,9 +17,8 @@ from .table_version_handle import TableVersionHandle
 from .table_version_path import TableVersionPath
 
 if TYPE_CHECKING:
-    import datasets  # type: ignore[import-untyped]
-
-    from pixeltable.globals import RowData, TableDataSource
+    from pixeltable import exprs
+    from pixeltable.globals import TableDataSource
     from pixeltable.io.table_data_conduit import TableDataConduit
 
 _logger = logging.getLogger('pixeltable')
@@ -167,7 +165,7 @@ class InsertableTable(Table):
         self, data_source: TableDataConduit, fail_on_exception: bool, print_stats: bool = False
     ) -> pxt.UpdateStatus:
         """Insert row batches into this table from a `TableDataConduit`."""
-        from pixeltable.io.table_data_conduit import DFTableDataConduit, TableDataConduit
+        from pixeltable.io.table_data_conduit import DFTableDataConduit
 
         status = pxt.UpdateStatus()
         with Env.get().begin_xact():
@@ -213,7 +211,7 @@ class InsertableTable(Table):
                     msg = str(e)
                     raise excs.Error(f'Error in column {col.name}: {msg[0].lower() + msg[1:]}\nRow: {row}') from e
 
-    def delete(self, where: Optional['pxt.exprs.Expr'] = None) -> UpdateStatus:
+    def delete(self, where: Optional['exprs.Expr'] = None) -> UpdateStatus:
         """Delete rows in this table.
 
         Args:

pixeltable/catalog/path.py

@@ -11,8 +11,8 @@ _logger = logging.getLogger('pixeltable')
 
 
 class Path:
-    def __init__(self, path: str, empty_is_valid: bool = False):
-        if not is_valid_path(path, empty_is_valid):
+    def __init__(self, path: str, empty_is_valid: bool = False, allow_system_paths: bool = False):
+        if not is_valid_path(path, empty_is_valid, allow_system_paths):
             raise excs.Error(f"Invalid path format: '{path}'")
         self.components = path.split('.')
 
@@ -27,7 +27,11 @@ class Path:
 
     @property
     def is_root(self) -> bool:
-        return self.components[0] == ''
+        return not self.components[0]
+
+    @property
+    def is_system_path(self) -> bool:
+        return self.components[0].startswith('_')
 
     @property
     def parent(self) -> Path:
@@ -35,15 +39,15 @@ class Path:
             if self.is_root:
                 return self
             else:
-                return Path('', empty_is_valid=True)
+                return Path('', empty_is_valid=True, allow_system_paths=True)
         else:
-            return Path('.'.join(self.components[:-1]))
+            return Path('.'.join(self.components[:-1]), allow_system_paths=True)
 
     def append(self, name: str) -> Path:
         if self.is_root:
-            return Path(name)
+            return Path(name, allow_system_paths=True)
         else:
-            return Path(f'{str(self)}.{name}')
+            return Path(f'{self}.{name}', allow_system_paths=True)
 
     def is_ancestor(self, other: Path, is_parent: bool = False) -> bool:
         """
@@ -67,6 +71,9 @@ class Path:
             for i in range(0, len(self.components)):
                 yield Path('.'.join(self.components[0:i]), empty_is_valid=True)
 
+    def __repr__(self) -> str:
+        return repr(str(self))
+
     def __str__(self) -> str:
         return '.'.join(self.components)
 

pixeltable/catalog/table.py

@@ -15,14 +15,9 @@ import pandas as pd
 import sqlalchemy as sql
 
 import pixeltable as pxt
-import pixeltable.catalog as catalog
-import pixeltable.env as env
-import pixeltable.exceptions as excs
-import pixeltable.exprs as exprs
-import pixeltable.index as index
-import pixeltable.metadata.schema as schema
-import pixeltable.type_system as ts
+from pixeltable import catalog, env, exceptions as excs, exprs, index, type_system as ts
 from pixeltable.env import Env
+from pixeltable.metadata import schema
 
 from ..exprs import ColumnRef
 from ..utils.description_helper import DescriptionHelper
@@ -38,16 +33,14 @@ from .globals import (
     is_valid_identifier,
 )
 from .schema_object import SchemaObject
-from .table_version import TableVersion
 from .table_version_handle import TableVersionHandle
 from .table_version_path import TableVersionPath
 
 if TYPE_CHECKING:
-    import datasets  # type: ignore[import-untyped]
     import torch.utils.data
 
     import pixeltable.plan
-    from pixeltable.globals import RowData, TableDataSource
+    from pixeltable.globals import TableDataSource
 
 _logger = logging.getLogger('pixeltable')
 
@@ -82,7 +75,7 @@ class Table(SchemaObject):
             (
                 f'UPDATE {schema.Table.__table__} '
                 f'SET {schema.Table.dir_id.name} = :new_dir_id, '
-                f"    {schema.Table.md.name}['name'] = :new_name "
+                f"    {schema.Table.md.name} = jsonb_set({schema.Table.md.name}, '{{name}}', (:new_name)::jsonb) "
                 f'WHERE {schema.Table.id.name} = :id'
             )
         )
@@ -102,6 +95,7 @@ class Table(SchemaObject):
                         'col1': StringType(),
                         'col2': IntType(),
                     },
+                    'is_replica': False,
                     'version': 22,
                     'schema_version': 1,
                     'comment': '',
@@ -117,6 +111,7 @@ class Table(SchemaObject):
             md = super().get_metadata()
             md['base'] = self._base._path() if self._base is not None else None
             md['schema'] = self._schema
+            md['is_replica'] = self._tbl_version.get().is_replica
             md['version'] = self._version
             md['schema_version'] = self._tbl_version.get().schema_version
             md['comment'] = self._comment
@@ -146,14 +141,14 @@ class Table(SchemaObject):
         if self._is_dropped:
             raise excs.Error(f'{self._display_name()} {self._name} has been dropped')
 
-    def __getattr__(self, name: str) -> 'pxt.exprs.ColumnRef':
+    def __getattr__(self, name: str) -> 'exprs.ColumnRef':
         """Return a ColumnRef for the given name."""
         col = self._tbl_version_path.get_column(name)
         if col is None:
             raise AttributeError(f'Column {name!r} unknown')
         return ColumnRef(col)
 
-    def __getitem__(self, name: str) -> 'pxt.exprs.ColumnRef':
+    def __getitem__(self, name: str) -> 'exprs.ColumnRef':
         """Return a ColumnRef for the given name."""
         return getattr(self, name)
 
@@ -232,15 +227,15 @@ class Table(SchemaObject):
         """Return rows from this table."""
         return self._df().collect()
 
-    def show(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def show(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         """Return rows from this table."""
         return self._df().show(*args, **kwargs)
 
-    def head(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def head(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         """Return the first n rows inserted into this table."""
         return self._df().head(*args, **kwargs)
 
-    def tail(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def tail(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         """Return the last n rows inserted into this table."""
         return self._df().tail(*args, **kwargs)
 
@@ -287,7 +282,7 @@ class Table(SchemaObject):
         return self._tbl_version.get().comment
 
     @property
-    def _num_retained_versions(self):
+    def _num_retained_versions(self) -> int:
         return self._tbl_version.get().num_retained_versions
 
     @property
@@ -406,12 +401,12 @@ class Table(SchemaObject):
     def _column_has_dependents(self, col: Column) -> bool:
         """Returns True if the column has dependents, False otherwise."""
         assert col is not None
-        assert col.name in self._schema.keys()
+        assert col.name in self._schema
         if any(c.name is not None for c in col.dependent_cols):
             return True
         return any(
             col in store.get_local_columns()
-            for view in [self] + self._get_views(recursive=True)
+            for view in (self, *self._get_views(recursive=True))
             for store in view._tbl_version.get().external_stores.values()
         )
 
@@ -429,7 +424,7 @@ class Table(SchemaObject):
                     raise excs.Error(f'Duplicate column name: {new_col_name!r}')
                 elif if_exists == IfExistsParam.IGNORE:
                     cols_to_ignore.append(new_col_name)
-                elif if_exists == IfExistsParam.REPLACE or if_exists == IfExistsParam.REPLACE_FORCE:
+                elif if_exists in (IfExistsParam.REPLACE, IfExistsParam.REPLACE_FORCE):
                     if new_col_name not in self._tbl_version.get().cols_by_name:
                         # for views, it is possible that the existing column
                         # is a base table column; in that case, we should not
@@ -440,7 +435,8 @@ class Table(SchemaObject):
                     # replace directive if column has dependents.
                     if self._column_has_dependents(col):
                         raise excs.Error(
-                            f'Column {new_col_name!r} already exists and has dependents. Cannot {if_exists.name.lower()} it.'
+                            f'Column {new_col_name!r} already exists and has dependents. '
+                            f'Cannot {if_exists.name.lower()} it.'
                         )
                     self.drop_column(new_col_name)
                     assert new_col_name not in self._tbl_version.get().cols_by_name
@@ -452,8 +448,8 @@ class Table(SchemaObject):
         if_exists: Literal['error', 'ignore', 'replace', 'replace_force'] = 'error',
     ) -> UpdateStatus:
         """
-        Adds multiple columns to the table. The columns must be concrete (non-computed) columns; to add computed columns,
-        use [`add_computed_column()`][pixeltable.catalog.Table.add_computed_column] instead.
+        Adds multiple columns to the table. The columns must be concrete (non-computed) columns; to add computed
+        columns, use [`add_computed_column()`][pixeltable.catalog.Table.add_computed_column] instead.
 
         The format of the `schema` argument is identical to the format of the schema in a call to
         [`create_table()`][pixeltable.globals.create_table].
@@ -464,10 +460,12 @@ class Table(SchemaObject):
 
                 - `'error'`: an exception will be raised.
                 - `'ignore'`: do nothing and return.
-                - `'replace' or 'replace_force'`: drop the existing column and add the new column, if it has no dependents.
+                - `'replace' or 'replace_force'`: drop the existing column and add the new column, if it has no
+                    dependents.
 
                 Note that the `if_exists` parameter is applied to all columns in the schema.
-                To apply different behaviors to different columns, please use [`add_column()`][pixeltable.Table.add_column] for each column.
+                To apply different behaviors to different columns, please use
+                [`add_column()`][pixeltable.Table.add_column] for each column.
 
         Returns:
             Information about the execution status of the operation.
@@ -528,7 +526,8 @@ class Table(SchemaObject):
 
                 - `'error'`: an exception will be raised.
                 - `'ignore'`: do nothing and return.
-                - `'replace' or 'replace_force'`: drop the existing column and add the new column, if it has no dependents.
+                - `'replace' or 'replace_force'`: drop the existing column and add the new column, if it has
+                    no dependents.
 
         Returns:
             Information about the execution status of the operation.
@@ -559,7 +558,7 @@ class Table(SchemaObject):
         col_type = next(iter(kwargs.values()))
         if not isinstance(col_type, (ts.ColumnType, type, _GenericAlias)):
             raise excs.Error(
-                f'The argument to add_column() must be a type; did you intend to use add_computed_column() instead?'
+                'The argument to add_column() must be a type; did you intend to use add_computed_column() instead?'
             )
         return self.add_columns(kwargs, if_exists=if_exists)
 
@@ -590,7 +589,8 @@ class Table(SchemaObject):
 
                 - `'error'`: an exception will be raised.
                 - `'ignore'`: do nothing and return.
-                - `'replace' or 'replace_force'`: drop the existing column and add the new column, iff it has no dependents.
+                - `'replace' or 'replace_force'`: drop the existing column and add the new column, iff it has
+                    no dependents.
 
         Returns:
             Information about the execution status of the operation.
@@ -614,7 +614,8 @@ class Table(SchemaObject):
             raise excs.Error('Cannot add column to a snapshot.')
         if len(kwargs) != 1:
             raise excs.Error(
-                f'add_computed_column() requires exactly one keyword argument of the form "column-name=type|value-expression"; '
+                f'add_computed_column() requires exactly one keyword argument of the form '
+                '"column-name=type|value-expression"; '
                 f'got {len(kwargs)} arguments instead ({", ".join(list(kwargs.keys()))})'
             )
         col_name, spec = next(iter(kwargs.items()))
@@ -625,6 +626,15 @@ class Table(SchemaObject):
         if stored is not None:
             col_schema['stored'] = stored
 
+        # Raise an error if the column expression refers to a column error property
+        if isinstance(spec, exprs.Expr):
+            for e in spec.subexprs(expr_class=exprs.ColumnPropertyRef, traverse_matches=False):
+                if e.is_error_prop():
+                    raise excs.Error(
+                        'Use of a reference to an error property of another column is not allowed in a computed '
+                        f'column. The specified computation for this column contains this reference: `{e!r}`'
+                    )
+
         with Env.get().begin_xact():
             # handle existing columns based on if_exists parameter
             cols_to_ignore = self._ignore_or_drop_existing_columns(
@@ -651,16 +661,15 @@ class Table(SchemaObject):
         """
         assert isinstance(spec, dict)
         valid_keys = {'type', 'value', 'stored', 'media_validation'}
-        for k in spec.keys():
+        for k in spec:
             if k not in valid_keys:
                 raise excs.Error(f'Column {name}: invalid key {k!r}')
 
         if 'type' not in spec and 'value' not in spec:
             raise excs.Error(f"Column {name}: 'type' or 'value' must be specified")
 
-        if 'type' in spec:
-            if not isinstance(spec['type'], (ts.ColumnType, type, _GenericAlias)):
-                raise excs.Error(f'Column {name}: "type" must be a type or ColumnType, got {spec["type"]}')
+        if 'type' in spec and not isinstance(spec['type'], (ts.ColumnType, type, _GenericAlias)):
+            raise excs.Error(f'Column {name}: "type" must be a type or ColumnType, got {spec["type"]}')
 
         if 'value' in spec:
             value_expr = exprs.Expr.from_object(spec['value'])
@@ -682,7 +691,7 @@ class Table(SchemaObject):
         for name, spec in schema.items():
             col_type: Optional[ts.ColumnType] = None
             value_expr: Optional[exprs.Expr] = None
-            primary_key: Optional[bool] = None
+            primary_key: bool = False
             media_validation: Optional[catalog.MediaValidation] = None
             stored = True
 
@@ -704,7 +713,7 @@ class Table(SchemaObject):
                     value_expr = value_expr.copy()
                     value_expr.bind_rel_paths()
                 stored = spec.get('stored', True)
-                primary_key = spec.get('primary_key')
+                primary_key = spec.get('primary_key', False)
                 media_validation_str = spec.get('media_validation')
                 media_validation = (
                     catalog.MediaValidation[media_validation_str.upper()] if media_validation_str is not None else None
@@ -740,8 +749,8 @@ class Table(SchemaObject):
         if col.stored is False and col.has_window_fn_call():
             raise excs.Error(
                 (
-                    f'Column {col.name!r}: stored={col.stored} is not valid for image columns computed with a streaming '
-                    f'function'
+                    f'Column {col.name!r}: stored={col.stored} is not valid for image columns computed with a '
+                    f'streaming function'
                 )
             )
 
@@ -787,21 +796,21 @@ class Table(SchemaObject):
         if self._tbl_version_path.is_snapshot():
             raise excs.Error('Cannot drop column from a snapshot.')
         col: Column = None
-        _if_not_exists = IfNotExistsParam.validated(if_not_exists, 'if_not_exists')
+        if_not_exists_ = IfNotExistsParam.validated(if_not_exists, 'if_not_exists')
         if isinstance(column, str):
             col = self._tbl_version_path.get_column(column, include_bases=False)
             if col is None:
-                if _if_not_exists == IfNotExistsParam.ERROR:
+                if if_not_exists_ == IfNotExistsParam.ERROR:
                     raise excs.Error(f'Column {column!r} unknown')
-                assert _if_not_exists == IfNotExistsParam.IGNORE
+                assert if_not_exists_ == IfNotExistsParam.IGNORE
                 return
             col = self._tbl_version.get().cols_by_name[column]
         else:
             exists = self._tbl_version_path.has_column(column.col, include_bases=False)
             if not exists:
-                if _if_not_exists == IfNotExistsParam.ERROR:
+                if if_not_exists_ == IfNotExistsParam.ERROR:
                     raise excs.Error(f'Unknown column: {column.col.qualified_name}')
-                assert _if_not_exists == IfNotExistsParam.IGNORE
+                assert if_not_exists_ == IfNotExistsParam.IGNORE
                 return
             col = column.col
 
@@ -817,7 +826,7 @@ class Table(SchemaObject):
             # (transitive) views of this table.
             dependent_stores = [
                 (view, store)
-                for view in [self] + self._get_views(recursive=True)
+                for view in (self, *self._get_views(recursive=True))
                 for store in view._tbl_version.get().external_stores.values()
                 if col in store.get_local_columns()
             ]
@@ -924,7 +933,8 @@ class Table(SchemaObject):
                 - `'replace'` or `'replace_force'`: replace the existing index with the new one.
 
         Raises:
-            Error: If an index with the specified name already exists for the table and `if_exists='error'`, or if the specified column does not exist.
+            Error: If an index with the specified name already exists for the table and `if_exists='error'`, or if
+                the specified column does not exist.
 
         Examples:
             Add an index to the `img` column of the table `my_table`:
@@ -962,18 +972,18 @@ class Table(SchemaObject):
 
         with Env.get().begin_xact():
             if idx_name is not None and idx_name in self._tbl_version.get().idxs_by_name:
-                _if_exists = IfExistsParam.validated(if_exists, 'if_exists')
+                if_exists_ = IfExistsParam.validated(if_exists, 'if_exists')
                 # An index with the same name already exists.
                 # Handle it according to if_exists.
-                if _if_exists == IfExistsParam.ERROR:
+                if if_exists_ == IfExistsParam.ERROR:
                     raise excs.Error(f'Duplicate index name: {idx_name}')
                 if not isinstance(self._tbl_version.get().idxs_by_name[idx_name].idx, index.EmbeddingIndex):
                     raise excs.Error(
-                        f'Index `{idx_name}` is not an embedding index. Cannot {_if_exists.name.lower()} it.'
+                        f'Index `{idx_name}` is not an embedding index. Cannot {if_exists_.name.lower()} it.'
                     )
-                if _if_exists == IfExistsParam.IGNORE:
+                if if_exists_ == IfExistsParam.IGNORE:
                     return
-                assert _if_exists == IfExistsParam.REPLACE or _if_exists == IfExistsParam.REPLACE_FORCE
+                assert if_exists_ in (IfExistsParam.REPLACE, IfExistsParam.REPLACE_FORCE)
                 self.drop_index(idx_name=idx_name)
                 assert idx_name not in self._tbl_version.get().idxs_by_name
             from pixeltable.index import EmbeddingIndex
@@ -986,7 +996,7 @@ class Table(SchemaObject):
             idx = EmbeddingIndex(
                 col, metric=metric, embed=embedding, string_embed=string_embed, image_embed=image_embed
             )
-            status = self._tbl_version.get().add_index(col, idx_name=idx_name, idx=idx)
+            _ = self._tbl_version.get().add_index(col, idx_name=idx_name, idx=idx)
             # TODO: how to deal with exceptions here? drop the index and raise?
             FileCache.get().emit_eviction_warnings()
 
@@ -1141,11 +1151,11 @@ class Table(SchemaObject):
         assert (col is None) != (idx_name is None)
 
         if idx_name is not None:
-            _if_not_exists = IfNotExistsParam.validated(if_not_exists, 'if_not_exists')
+            if_not_exists_ = IfNotExistsParam.validated(if_not_exists, 'if_not_exists')
             if idx_name not in self._tbl_version.get().idxs_by_name:
-                if _if_not_exists == IfNotExistsParam.ERROR:
+                if if_not_exists_ == IfNotExistsParam.ERROR:
                     raise excs.Error(f'Index {idx_name!r} does not exist')
-                assert _if_not_exists == IfNotExistsParam.IGNORE
+                assert if_not_exists_ == IfNotExistsParam.IGNORE
                 return
             idx_info = self._tbl_version.get().idxs_by_name[idx_name]
         else:
@@ -1157,10 +1167,10 @@ class Table(SchemaObject):
             if _idx_class is not None:
                 idx_info_list = [info for info in idx_info_list if isinstance(info.idx, _idx_class)]
             if len(idx_info_list) == 0:
-                _if_not_exists = IfNotExistsParam.validated(if_not_exists, 'if_not_exists')
-                if _if_not_exists == IfNotExistsParam.ERROR:
+                if_not_exists_ = IfNotExistsParam.validated(if_not_exists, 'if_not_exists')
+                if if_not_exists_ == IfNotExistsParam.ERROR:
                     raise excs.Error(f'Column {col.name!r} does not have an index')
-                assert _if_not_exists == IfNotExistsParam.IGNORE
+                assert if_not_exists_ == IfNotExistsParam.IGNORE
                 return
             if len(idx_info_list) > 1:
                 raise excs.Error(f"Column {col.name!r} has multiple indices; specify 'idx_name' instead")
@@ -1274,7 +1284,7 @@ class Table(SchemaObject):
         raise NotImplementedError
 
     def update(
-        self, value_spec: dict[str, Any], where: Optional['pxt.exprs.Expr'] = None, cascade: bool = True
+        self, value_spec: dict[str, Any], where: Optional['exprs.Expr'] = None, cascade: bool = True
     ) -> UpdateStatus:
         """Update rows in this table.
 
@@ -1341,7 +1351,7 @@ class Table(SchemaObject):
         rows = list(rows)
 
         row_updates: list[dict[Column, exprs.Expr]] = []
-        pk_col_names = set(c.name for c in self._tbl_version.get().primary_key_columns())
+        pk_col_names = {c.name for c in self._tbl_version.get().primary_key_columns()}
 
         # pseudo-column _rowid: contains the rowid of the row to update and can be used instead of the primary key
         has_rowid = _ROWID_COLUMN_NAME in rows[0]
@@ -1351,16 +1361,16 @@ class Table(SchemaObject):
 
         for row_spec in rows:
             col_vals = self._tbl_version.get()._validate_update_spec(
-                row_spec, allow_pk=not has_rowid, allow_exprs=False
+                row_spec, allow_pk=not has_rowid, allow_exprs=False, allow_media=False
             )
             if has_rowid:
                 # we expect the _rowid column to be present for each row
                 assert _ROWID_COLUMN_NAME in row_spec
                 rowids.append(row_spec[_ROWID_COLUMN_NAME])
             else:
-                col_names = set(col.name for col in col_vals.keys())
+                col_names = {col.name for col in col_vals}
                 if any(pk_col_name not in col_names for pk_col_name in pk_col_names):
-                    missing_cols = pk_col_names - set(col.name for col in col_vals.keys())
+                    missing_cols = pk_col_names - {col.name for col in col_vals}
                     raise excs.Error(f'Primary key columns ({", ".join(missing_cols)}) missing in {row_spec}')
             row_updates.append(col_vals)
 
@@ -1375,7 +1385,7 @@ class Table(SchemaObject):
             FileCache.get().emit_eviction_warnings()
             return status
 
-    def delete(self, where: Optional['pxt.exprs.Expr'] = None) -> UpdateStatus:
+    def delete(self, where: Optional['exprs.Expr'] = None) -> UpdateStatus:
         """Delete rows in this table.
 
         Args: