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

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'
             )
         )
@@ -232,15 +225,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 +280,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 +399,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 +422,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 +433,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 +446,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 +458,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 +524,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 +556,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 +587,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 +612,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 +624,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 +659,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'])
@@ -740,8 +747,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 +794,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 +824,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 +931,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 +970,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 +994,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 +1149,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 +1165,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")
@@ -1341,7 +1349,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 +1359,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)
 

pixeltable/catalog/table_version.py

@@ -13,9 +13,8 @@ import sqlalchemy as sql
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
-import pixeltable.exprs as exprs
-import pixeltable.index as index
 import pixeltable.type_system as ts
+from pixeltable import exprs, index
 from pixeltable.env import Env
 from pixeltable.iterators import ComponentIterator
 from pixeltable.metadata import schema
@@ -54,6 +53,7 @@ class TableVersion:
 
     id: UUID
     name: str
+    user: Optional[str]
     effective_version: Optional[int]
     version: int
     comment: str
@@ -108,6 +108,7 @@ class TableVersion:
     ):
         self.id = id
         self.name = tbl_md.name
+        self.user = tbl_md.user
         self.effective_version = effective_version
         self.version = tbl_md.current_version if effective_version is None else effective_version
         self.comment = schema_version_md.comment
@@ -211,6 +212,7 @@ class TableVersion:
         view_md: Optional[schema.ViewMd] = None,
     ) -> tuple[UUID, Optional[TableVersion]]:
         session = Env.get().session
+        user = Env.get().user
 
         # assign ids
         cols_by_name: dict[str, Column] = {}
@@ -229,7 +231,7 @@ class TableVersion:
         table_md = schema.TableMd(
             tbl_id=str(tbl_id),
             name=name,
-            user=None,
+            user=user,
             current_version=0,
             current_schema_version=0,
             next_col_id=len(cols),
@@ -341,8 +343,11 @@ class TableVersion:
         self.cols = []
         self.cols_by_name = {}
         self.cols_by_id = {}
-        for col_md in tbl_md.column_md.values():
-            schema_col_md = schema_version_md.columns[col_md.id] if col_md.id in schema_version_md.columns else None
+        # Sort columns in column_md by the position specified in col_md.id to guarantee that all references
+        # point backward.
+        sorted_column_md = sorted(tbl_md.column_md.values(), key=lambda item: item.id)
+        for col_md in sorted_column_md:
+            schema_col_md = schema_version_md.columns.get(col_md.id)
             col_name = schema_col_md.name if schema_col_md is not None else None
             media_val = (
                 MediaValidation[schema_col_md.media_validation.upper()]
@@ -385,10 +390,8 @@ class TableVersion:
         import pixeltable.index as index_module
 
         for md in tbl_md.index_md.values():
-            if (
-                md.schema_version_add > self.schema_version
-                or md.schema_version_drop is not None
-                and md.schema_version_drop <= self.schema_version
+            if md.schema_version_add > self.schema_version or (
+                md.schema_version_drop is not None and md.schema_version_drop <= self.schema_version
             ):
                 # index not visible in this schema version
                 continue
@@ -619,11 +622,10 @@ class TableVersion:
         cols = list(cols)
         row_count = self.store_tbl.count()
         for col in cols:
-            if not col.col_type.nullable and not col.is_computed:
-                if row_count > 0:
-                    raise excs.Error(
-                        f'Cannot add non-nullable column "{col.name}" to table {self.name} with existing rows'
-                    )
+            if not col.col_type.nullable and not col.is_computed and row_count > 0:
+                raise excs.Error(
+                    f'Cannot add non-nullable column {col.name!r} to table {self.name!r} with existing rows'
+                )
 
         num_excs = 0
         cols_with_excs: list[Column] = []
@@ -662,13 +664,13 @@ class TableVersion:
                     cols_with_excs.append(col)
             except excs.Error as exc:
                 self.cols.pop()
-                for col in cols:
+                for c in cols:
                     # remove columns that we already added
-                    if col.id not in self.cols_by_id:
+                    if c.id not in self.cols_by_id:
                         continue
-                    if col.name is not None:
-                        del self.cols_by_name[col.name]
-                    del self.cols_by_id[col.id]
+                    if c.name is not None:
+                        del self.cols_by_name[c.name]
+                    del self.cols_by_id[c.id]
                 # we need to re-initialize the sqlalchemy schema
                 self.store_tbl.create_sa_tbl()
                 raise exc
@@ -756,19 +758,20 @@ class TableVersion:
         self._update_md(time.time(), preceding_schema_version=preceding_schema_version)
         _logger.info(f'Renamed column {old_name} to {new_name} in table {self.name}, new version: {self.version}')
 
-    def set_comment(self, new_comment: Optional[str]):
+    def set_comment(self, new_comment: Optional[str]) -> None:
         _logger.info(f'[{self.name}] Updating comment: {new_comment}')
         self.comment = new_comment
         self._create_schema_version()
 
-    def set_num_retained_versions(self, new_num_retained_versions: int):
+    def set_num_retained_versions(self, new_num_retained_versions: int) -> None:
         _logger.info(
-            f'[{self.name}] Updating num_retained_versions: {new_num_retained_versions} (was {self.num_retained_versions})'
+            f'[{self.name}] Updating num_retained_versions: {new_num_retained_versions} '
+            f'(was {self.num_retained_versions})'
         )
         self.num_retained_versions = new_num_retained_versions
         self._create_schema_version()
 
-    def _create_schema_version(self):
+    def _create_schema_version(self) -> None:
         # we're creating a new schema version
         self.version += 1
         preceding_schema_version = self.schema_version
@@ -858,7 +861,7 @@ class TableVersion:
 
         from pixeltable.plan import Planner
 
-        update_spec = self._validate_update_spec(value_spec, allow_pk=False, allow_exprs=True)
+        update_spec = self._validate_update_spec(value_spec, allow_pk=False, allow_exprs=True, allow_media=True)
         if where is not None:
             if not isinstance(where, exprs.Expr):
                 raise excs.Error(f"'where' argument must be a predicate, got {type(where)}")
@@ -897,7 +900,6 @@ class TableVersion:
         """
         # if we do lookups of rowids, we must have one for each row in the batch
         assert len(rowids) == 0 or len(rowids) == len(batch)
-        cols_with_excs: set[str] = set()
 
         from pixeltable.plan import Planner
 
@@ -919,7 +921,7 @@ class TableVersion:
         return result
 
     def _validate_update_spec(
-        self, value_spec: dict[str, Any], allow_pk: bool, allow_exprs: bool
+        self, value_spec: dict[str, Any], allow_pk: bool, allow_exprs: bool, allow_media: bool
     ) -> dict[Column, exprs.Expr]:
         update_targets: dict[Column, exprs.Expr] = {}
         for col_name, val in value_spec.items():
@@ -939,27 +941,31 @@ class TableVersion:
                 raise excs.Error(f'Column {col_name} is computed and cannot be updated')
             if col.is_pk and not allow_pk:
                 raise excs.Error(f'Column {col_name} is a primary key column and cannot be updated')
+            if col.col_type.is_media_type() and not allow_media:
+                raise excs.Error(f'Column {col_name} is a media column and cannot be updated')
 
             # make sure that the value is compatible with the column type
             value_expr: exprs.Expr
             try:
                 # check if this is a literal
                 value_expr = exprs.Literal(val, col_type=col.col_type)
-            except (TypeError, jsonschema.exceptions.ValidationError):
+            except (TypeError, jsonschema.exceptions.ValidationError) as exc:
                 if not allow_exprs:
                     raise excs.Error(
                         f'Column {col_name}: value {val!r} is not a valid literal for this column '
                         f'(expected {col.col_type})'
-                    )
+                    ) from exc
                 # it's not a literal, let's try to create an expr from it
                 value_expr = exprs.Expr.from_object(val)
                 if value_expr is None:
-                    raise excs.Error(f'Column {col_name}: value {val!r} is not a recognized literal or expression')
+                    raise excs.Error(
+                        f'Column {col_name}: value {val!r} is not a recognized literal or expression'
+                    ) from exc
                 if not col.col_type.is_supertype_of(value_expr.col_type, ignore_nullable=True):
                     raise excs.Error(
                         f'Type of value {val!r} ({value_expr.col_type}) is not compatible with the type of column '
                         f'{col_name} ({col.col_type})'
-                    )
+                    ) from exc
             update_targets[col] = value_expr
 
         return update_targets
@@ -988,7 +994,7 @@ class TableVersion:
             self._update_md(timestamp)
 
         if cascade:
-            base_versions = [None if plan is None else self.version] + base_versions  # don't update in place
+            base_versions = [None if plan is None else self.version, *base_versions]  # don't update in place
             # propagate to views
             for view in self.mutable_views:
                 recomputed_cols = [col for col in recomputed_view_cols if col.tbl == view]
@@ -1048,11 +1054,9 @@ class TableVersion:
             # we're creating a new version
             self.version += 1
             self._update_md(timestamp)
-        else:
-            pass
         for view in self.mutable_views:
             num_rows += view.get().propagate_delete(
-                where=None, base_versions=[self.version] + base_versions, timestamp=timestamp
+                where=None, base_versions=[self.version, *base_versions], timestamp=timestamp
             )
         return num_rows
 
@@ -1232,9 +1236,7 @@ class TableVersion:
 
     def is_system_column(self, col: Column) -> bool:
         """Return True if column was created by Pixeltable"""
-        if col.name == _POS_COLUMN_NAME and self.is_component_view:
-            return True
-        return False
+        return col.name == _POS_COLUMN_NAME and self.is_component_view
 
     def user_columns(self) -> list[Column]:
         """Return all non-system columns"""
@@ -1262,7 +1264,7 @@ class TableVersion:
 
     def _record_refd_columns(self, col: Column) -> None:
         """Update Column.dependent_cols for all cols referenced in col.value_expr."""
-        import pixeltable.exprs as exprs
+        from pixeltable import exprs
 
         if col.value_expr_dict is not None:
             # if we have a value_expr_dict, use that instead of instantiating the value_expr
@@ -1317,7 +1319,7 @@ class TableVersion:
         return schema.TableMd(
             tbl_id=str(self.id),
             name=self.name,
-            user=None,
+            user=self.user,
             current_version=self.version,
             current_schema_version=self.schema_version,
             next_col_id=self.next_col_id,
@@ -1364,7 +1366,7 @@ class TableVersion:
 
     @classmethod
     def from_dict(cls, d: dict) -> TableVersion:
-        import pixeltable.catalog as catalog
+        from pixeltable import catalog
 
         id = UUID(d['id'])
         effective_version = d['effective_version']

pixeltable/catalog/table_version_handle.py

@@ -31,6 +31,9 @@ class TableVersionHandle:
             return False
         return self.id == other.id and self.effective_version == other.effective_version
 
+    def __hash__(self) -> int:
+        return hash((self.id, self.effective_version))
+
     @classmethod
     def create(cls, tbl_version: TableVersion) -> TableVersionHandle:
         return cls(tbl_version.id, tbl_version.effective_version, tbl_version)

pixeltable/catalog/table_version_path.py

@@ -82,7 +82,7 @@ class TableVersionPath:
         """Return all tbl versions"""
         if self.base is None:
             return [self.tbl_version]
-        return [self.tbl_version] + self.base.get_tbl_versions()
+        return [self.tbl_version, *self.base.get_tbl_versions()]
 
     def get_bases(self) -> list[TableVersionHandle]:
         """Return all tbl versions"""

pixeltable/catalog/view.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 import inspect
 import logging
-from typing import TYPE_CHECKING, Any, Iterable, List, Literal, Optional
+from typing import TYPE_CHECKING, Any, List, Literal, Optional
 from uuid import UUID
 
 import pixeltable.exceptions as excs
 import pixeltable.metadata.schema as md_schema
 import pixeltable.type_system as ts
-from pixeltable import catalog, exprs, func
+from pixeltable import exprs, func
 from pixeltable.env import Env
 from pixeltable.iterators import ComponentIterator
 
@@ -98,7 +98,8 @@ class View(Table):
             # make sure that the value can be computed in the context of the base
             if col.value_expr is not None and not col.value_expr.is_bound_by([base]):
                 raise excs.Error(
-                    f'Column {col.name}: value expression cannot be computed in the context of the base {base.tbl_name()}'
+                    f'Column {col.name}: value expression cannot be computed in the context of the '
+                    f'base {base.tbl_name()}'
                 )
 
         if iterator_cls is not None:
@@ -111,8 +112,8 @@ class View(Table):
             bound_args: dict[str, Any]
             try:
                 bound_args = py_signature.bind(None, **iterator_args).arguments  # None: arg for self
-            except TypeError as e:
-                raise excs.Error(f'Invalid iterator arguments: {e}')
+            except TypeError as exc:
+                raise excs.Error(f'Invalid iterator arguments: {exc}') from exc
             # we ignore 'self'
             first_param_name = next(iter(py_signature.parameters))  # can't guarantee it's actually 'self'
             del bound_args[first_param_name]
@@ -203,8 +204,8 @@ class View(Table):
 
             from pixeltable.plan import Planner
 
-            plan, num_values_per_row = Planner.create_view_load_plan(view._tbl_version_path)
-            num_rows, num_excs, cols_with_excs = tbl_version.store_tbl.insert_rows(plan, v_min=tbl_version.version)
+            plan, _ = Planner.create_view_load_plan(view._tbl_version_path)
+            num_rows, num_excs, _ = tbl_version.store_tbl.insert_rows(plan, v_min=tbl_version.version)
             Env.get().console_logger.info(f'Created view `{name}` with {num_rows} rows, {num_excs} exceptions.')
 
         session.commit()