pixeltable 0.2.14__py3-none-any.whl → 0.2.16__py3-none-any.whl

pixeltable/catalog/table.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+import abc
+import itertools
 import json
 import logging
 from pathlib import Path
-from typing import Union, Any, Optional, Callable, Set, Tuple, Iterable, overload, Type, Literal
+from typing import Any, Callable, Iterable, Literal, Optional, Set, Tuple, Type, Union, overload
 from uuid import UUID
-import abc
 
 import pandas as pd
 import sqlalchemy as sql
@@ -18,8 +19,9 @@ import pixeltable.exprs as exprs
 import pixeltable.index as index
 import pixeltable.metadata.schema as schema
 import pixeltable.type_system as ts
+
 from .column import Column
-from .globals import _ROWID_COLUMN_NAME, is_valid_identifier, is_system_column_name, UpdateStatus
+from .globals import _ROWID_COLUMN_NAME, UpdateStatus, is_system_column_name, is_valid_identifier
 from .schema_object import SchemaObject
 from .table_version import TableVersion
 from .table_version_path import TableVersionPath
@@ -27,7 +29,7 @@ from .table_version_path import TableVersionPath
 _logger = logging.getLogger('pixeltable')
 
 class Table(SchemaObject):
-    """Base class for all tabular SchemaObjects."""
+    """Base class for table objects (base tables, views, snapshots)."""
 
     def __init__(self, id: UUID, dir_id: UUID, name: str, tbl_version_path: TableVersionPath):
         super().__init__(id, name, dir_id)
@@ -46,7 +48,18 @@ class Table(SchemaObject):
                 f"WHERE {schema.Table.id.name} = :id"))
             conn.execute(stmt, {'new_dir_id': new_dir_id, 'new_name': json.dumps(new_name), 'id': self._id})
 
-    def version(self) -> int:
+    def get_metadata(self) -> dict[str, Any]:
+        md = super().get_metadata()
+        md['base'] = self._base._path if self._base is not None else None
+        md['schema'] = self._schema
+        md['version'] = self._version
+        md['schema_version'] = self._tbl_version.schema_version
+        md['comment'] = self._comment
+        md['num_retained_versions'] = self._num_retained_versions
+        return md
+
+    @property
+    def _version(self) -> int:
         """Return the version of this table. Used by tests to ascertain version changes."""
         return self._tbl_version.version
 
@@ -60,7 +73,7 @@ class Table(SchemaObject):
 
     def _check_is_dropped(self) -> None:
         if self._is_dropped:
-            raise excs.Error(f'{self.display_name()} {self.name} has been dropped')
+            raise excs.Error(f'{self._display_name()} {self._name} has been dropped')
 
     def __getattr__(
             self, name: str
@@ -74,7 +87,7 @@ class Table(SchemaObject):
     def __getitem__(
             self, index: object
     ) -> Union[
-        'pixeltable.func.QueryTemplateFunction', 'pixeltable.exprs.ColumnRef', 'pixeltable.dataframe.DataFrame'
+        'pixeltable.func.QueryTemplateFunction', 'pixeltable.exprs.ColumnRef', 'pixeltable.DataFrame'
     ]:
         """Return a ColumnRef or QueryTemplateFunction for the given name, or a DataFrame for the given slice.
         """
@@ -90,10 +103,10 @@ class Table(SchemaObject):
             recursive: If `False`, returns only the immediate successor views of this `Table`. If `True`, returns
                 all sub-views (including views of views, etc.)
         """
-        return [t.path for t in self._get_views(recursive=recursive)]
+        return [t._path for t in self._get_views(recursive=recursive)]
 
     def _get_views(self, *, recursive: bool = True) -> list['Table']:
-        dependents = catalog.Catalog.get().tbl_dependents[self._get_id()]
+        dependents = catalog.Catalog.get().tbl_dependents[self._id]
         if recursive:
             return dependents + [t for view in dependents for t in view._get_views(recursive=True)]
         else:
@@ -106,33 +119,30 @@ class Table(SchemaObject):
         from pixeltable.dataframe import DataFrame
         return DataFrame(self._tbl_version_path)
 
-    def select(self, *items: Any, **named_items: Any) -> 'pixeltable.dataframe.DataFrame':
-        """Return a DataFrame for this table.
-        """
+    def select(self, *items: Any, **named_items: Any) -> 'pixeltable.DataFrame':
+        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
         # local import: avoid circular imports
         from pixeltable.dataframe import DataFrame
         return DataFrame(self._tbl_version_path).select(*items, **named_items)
 
-    def where(self, pred: 'exprs.Expr') -> 'pixeltable.dataframe.DataFrame':
-        """Return a DataFrame for this table.
-        """
+    def where(self, pred: 'exprs.Expr') -> 'pixeltable.DataFrame':
+        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
         # local import: avoid circular imports
         from pixeltable.dataframe import DataFrame
         return DataFrame(self._tbl_version_path).where(pred)
 
-    def order_by(self, *items: 'exprs.Expr', asc: bool = True) -> 'pixeltable.dataframe.DataFrame':
-        """Return a DataFrame for this table.
-        """
+    def order_by(self, *items: 'exprs.Expr', asc: bool = True) -> 'pixeltable.DataFrame':
+        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
         # local import: avoid circular imports
         from pixeltable.dataframe import DataFrame
         return DataFrame(self._tbl_version_path).order_by(*items, asc=asc)
 
-    def group_by(self, *items: 'exprs.Expr') -> 'pixeltable.dataframe.DataFrame':
-        """Return a DataFrame for this table."""
+    def group_by(self, *items: 'exprs.Expr') -> 'pixeltable.DataFrame':
+        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
         from pixeltable.dataframe import DataFrame
         return DataFrame(self._tbl_version_path).group_by(*items)
 
-    def limit(self, n: int) -> 'pixeltable.dataframe.DataFrame':
+    def limit(self, n: int) -> 'pixeltable.DataFrame':
         from pixeltable.dataframe import DataFrame
         return DataFrame(self._tbl_version_path).limit(n)
 
@@ -163,20 +173,18 @@ class Table(SchemaObject):
         """Return the number of rows in this table."""
         return self._df().count()
 
-    def column_names(self) -> list[str]:
-        """Return the names of the columns in this table."""
-        return [c.name for c in self._tbl_version_path.columns()]
-
-    def column_types(self) -> dict[str, ts.ColumnType]:
-        """Return the names of the columns in this table."""
+    @property
+    def _schema(self) -> dict[str, ts.ColumnType]:
+        """Return the schema (column names and column types) of this table."""
         return {c.name: c.col_type for c in self._tbl_version_path.columns()}
 
-    def query_names(self) -> list[str]:
+    @property
+    def _query_names(self) -> list[str]:
         """Return the names of the registered queries for this table."""
         return list(self._queries.keys())
 
     @property
-    def base(self) -> Optional['Table']:
+    def _base(self) -> Optional['Table']:
         """
         The base table of this `Table`. If this table is a view, returns the `Table`
         from which it was derived. Otherwise, returns `None`.
@@ -187,21 +195,13 @@ class Table(SchemaObject):
         return catalog.Catalog.get().tbls[base_id]
 
     @property
-    def comment(self) -> str:
+    def _comment(self) -> str:
         return self._tbl_version.comment
 
-    @comment.setter
-    def comment(self, new_comment: Optional[str]):
-        self._tbl_version.set_comment(new_comment)
-
     @property
-    def num_retained_versions(self):
+    def _num_retained_versions(self):
         return self._tbl_version.num_retained_versions
 
-    @num_retained_versions.setter
-    def num_retained_versions(self, new_num_retained_versions: int):
-        self._tbl_version.set_num_retained_versions(new_num_retained_versions)
-
     def _description(self) -> pd.DataFrame:
         cols = self._tbl_version_path.columns()
         df = pd.DataFrame({
@@ -233,11 +233,11 @@ class Table(SchemaObject):
     # TODO: Display comments in _repr_html()
     def __repr__(self) -> str:
         description_str = self._description().to_string(index=False)
-        if self.comment is None:
+        if self._comment is None:
             comment = ''
         else:
-            comment = f'{self.comment}\n'
-        return f'{self.display_name()} \'{self._name}\'\n{comment}{description_str}'
+            comment = f'{self._comment}\n'
+        return f'{self._display_name()} \'{self._name}\'\n{comment}{description_str}'
 
     def _repr_html_(self) -> str:
         return self._description_html()._repr_html_()
@@ -266,51 +266,34 @@ class Table(SchemaObject):
         from pixeltable.dataframe import DataFrame
         return DataFrame(self._tbl_version_path).to_coco_dataset()
 
-    def __setitem__(self, column_name: str, value: Union[ts.ColumnType, exprs.Expr, Callable, dict]) -> None:
-        """Adds a column to the table
-        Args:
-            column_name: the name of the new column
-            value: column type or value expression or column specification dictionary:
-                column type: a Pixeltable column type (if the table already contains rows, it must be nullable)
-                value expression: a Pixeltable expression that computes the column values
-                column specification: a dictionary with possible keys 'type', 'value', 'stored'
-        Examples:
-            Add an int column with ``None`` values:
-
-            >>> tbl['new_col'] = IntType(nullable=True)
-
-            For a table with int column ``int_col``, add a column that is the factorial of ``int_col``. The names of
-            the parameters of the Callable must correspond to existing column names (the column values are then passed
-            as arguments to the Callable). In this case, the return type cannot be inferred and needs to be specified
-            explicitly:
-
-            >>> tbl['factorial'] = {'value': lambda int_col: math.factorial(int_col), 'type': IntType()}
+    def __setitem__(self, col_name: str, spec: Union[ts.ColumnType, exprs.Expr]) -> None:
+        """
+        Adds a column to the table. This is an alternate syntax for `add_column()`; the meaning of
 
-            For a table with an image column ``frame``, add an image column ``rotated`` that rotates the image by
-            90 degrees. In this case, the column type is inferred from the expression. Also, the column is not stored
-            (by default, computed image columns are not stored but recomputed on demand):
+        >>> tbl['new_col'] = IntType()
 
-            >>> tbl['rotated'] = tbl.frame.rotate(90)
+        is exactly equivalent to
 
-            Do the same, but now the column is stored:
+        >>> tbl.add_column(new_col=IntType())
 
-            >>> tbl['rotated'] = {'value': tbl.frame.rotate(90), 'stored': True}
+        For details, see the documentation for [`add_column()`][pixeltable.catalog.Table.add_column].
         """
-        if not isinstance(column_name, str):
-            raise excs.Error(f'Column name must be a string, got {type(column_name)}')
-        if not is_valid_identifier(column_name):
-            raise excs.Error(f'Invalid column name: {column_name!r}')
-
-        new_col = self._create_columns({column_name: value})[0]
-        self._verify_column(new_col, self.column_names(), self.query_names())
-        return self._tbl_version.add_column(new_col)
+        if not isinstance(col_name, str):
+            raise excs.Error(f'Column name must be a string, got {type(col_name)}')
+        if not isinstance(spec, (ts.ColumnType, exprs.Expr)):
+            raise excs.Error(f'Column spec must be a ColumnType or an Expr, got {type(spec)}')
+        self.add_column(**{col_name: spec})
 
     def add_column(
-            self, *,
-            type: Optional[ts.ColumnType] = None, stored: Optional[bool] = None, print_stats: bool = False,
-            **kwargs: Any
+            self,
+            *,
+            type: Optional[ts.ColumnType] = None,
+            stored: Optional[bool] = None,
+            print_stats: bool = False,
+            **kwargs: Union[ts.ColumnType, exprs.Expr, Callable]
     ) -> UpdateStatus:
-        """Adds a column to the table.
+        """
+        Adds a column to the table.
 
         Args:
             kwargs: Exactly one keyword argument of the form ``column-name=type|value-expression``.
@@ -364,19 +347,20 @@ class Table(SchemaObject):
         self._check_is_dropped()
         # verify kwargs and construct column schema dict
         if len(kwargs) != 1:
-            raise excs.Error((
-                f'add_column() requires exactly one keyword argument of the form "column-name=type|value-expression", '
+            raise excs.Error(
+                f'add_column() requires exactly one keyword argument of the form "column-name=type|value-expression"; '
                 f'got {len(kwargs)} instead ({", ".join(list(kwargs.keys()))})'
-            ))
+            )
         col_name, spec = next(iter(kwargs.items()))
+        if not is_valid_identifier(col_name):
+            raise excs.Error(f'Invalid column name: {col_name!r}')
+        if isinstance(spec, (ts.ColumnType, exprs.Expr)) and type is not None:
+            raise excs.Error(f'add_column(): keyword argument "type" is redundant')
+
         col_schema: dict[str, Any] = {}
         if isinstance(spec, ts.ColumnType):
-            if type is not None:
-                raise excs.Error(f'add_column(): keyword argument "type" is redundant')
             col_schema['type'] = spec
         else:
-            if isinstance(spec, exprs.Expr) and type is not None:
-                raise excs.Error(f'add_column(): keyword argument "type" is redundant')
             col_schema['value'] = spec
         if type is not None:
             col_schema['type'] = type
@@ -384,7 +368,7 @@ class Table(SchemaObject):
             col_schema['stored'] = stored
 
         new_col = self._create_columns({col_name: col_schema})[0]
-        self._verify_column(new_col, self.column_names(), self.query_names())
+        self._verify_column(new_col, set(self._schema.keys()), self._query_names)
         return self._tbl_version.add_column(new_col, print_stats=print_stats)
 
     @classmethod
@@ -434,8 +418,8 @@ class Table(SchemaObject):
         for name, spec in schema.items():
             col_type: Optional[ts.ColumnType] = None
             value_expr: Optional[exprs.Expr] = None
-            stored: Optional[bool] = None
             primary_key: Optional[bool] = None
+            stored = True
 
             if isinstance(spec, ts.ColumnType):
                 # TODO: create copy
@@ -455,7 +439,7 @@ class Table(SchemaObject):
                 if value_expr is not None and isinstance(value_expr, exprs.Expr):
                     # create copy so we can modify it
                     value_expr = value_expr.copy()
-                stored = spec.get('stored')
+                stored = spec.get('stored', True)
                 primary_key = spec.get('primary_key')
 
             column = Column(
@@ -469,7 +453,7 @@ class Table(SchemaObject):
     ) -> None:
         """Check integrity of user-supplied Column and supply defaults"""
         if is_system_column_name(col.name):
-            raise excs.Error(f'Column name {col.name!r} is reserved')
+            raise excs.Error(f'{col.name!r} is a reserved name in Pixeltable; please choose a different column name.')
         if not is_valid_identifier(col.name):
             raise excs.Error(f"Invalid column name: {col.name!r}")
         if col.name in existing_column_names:
@@ -478,12 +462,10 @@ class Table(SchemaObject):
             raise excs.Error(f'Column name conflicts with a registered query: {col.name!r}')
         if col.stored is False and not (col.is_computed and col.col_type.is_image_type()):
             raise excs.Error(f'Column {col.name!r}: stored={col.stored} only applies to computed image columns')
-        if col.stored is False and not (col.col_type.is_image_type() and not col.has_window_fn_call()):
+        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'))
-        if col.stored is None:
-            col.stored = not (col.is_computed and col.col_type.is_image_type() and not col.has_window_fn_call())
 
     @classmethod
     def _verify_schema(cls, schema: list[Column]) -> None:
@@ -530,7 +512,7 @@ class Table(SchemaObject):
         ]
         if len(dependent_stores) > 0:
             dependent_store_names = [
-                store.name if view._get_id() == self._get_id() else f'{store.name} (in view `{view.name}`)'
+                store.name if view._id == self._id else f'{store.name} (in view `{view._name}`)'
                 for view, store in dependent_stores
             ]
             raise excs.Error(
@@ -594,6 +576,7 @@ class Table(SchemaObject):
         if idx_name is not None and idx_name in self._tbl_version.idxs_by_name:
             raise excs.Error(f'Duplicate index name: {idx_name}')
         from pixeltable.index import EmbeddingIndex
+
         # create the EmbeddingIndex instance to verify args
         idx = EmbeddingIndex(col, metric=metric, string_embed=string_embed, image_embed=image_embed)
         status = self._tbl_version.add_index(col, idx_name=idx_name, idx=idx)
@@ -850,7 +833,7 @@ class Table(SchemaObject):
             else:
                 function_path = None
             query_name = py_fn.__name__
-            if query_name in self.column_names():
+            if query_name in self._schema.keys():
                 raise excs.Error(f'Query name {query_name!r} conflicts with existing column')
             if query_name in self._queries:
                 raise excs.Error(f'Duplicate query name: {query_name!r}')
@@ -879,13 +862,13 @@ class Table(SchemaObject):
         Links the specified `ExternalStore` to this table.
         """
         if self._tbl_version.is_snapshot:
-            raise excs.Error(f'Table `{self.name}` is a snapshot, so it cannot be linked to an external store.')
+            raise excs.Error(f'Table `{self._name}` is a snapshot, so it cannot be linked to an external store.')
         self._check_is_dropped()
         if store.name in self.external_stores:
-            raise excs.Error(f'Table `{self.name}` already has an external store with that name: {store.name}')
-        _logger.info(f'Linking external store `{store.name}` to table `{self.name}`')
+            raise excs.Error(f'Table `{self._name}` already has an external store with that name: {store.name}')
+        _logger.info(f'Linking external store `{store.name}` to table `{self._name}`')
         self._tbl_version.link_external_store(store)
-        print(f'Linked external store `{store.name}` to table `{self.name}`.')
+        print(f'Linked external store `{store.name}` to table `{self._name}`.')
 
     def unlink_external_stores(
             self,
@@ -917,11 +900,11 @@ class Table(SchemaObject):
         if not ignore_errors:
             for store in stores:
                 if store not in all_stores:
-                    raise excs.Error(f'Table `{self.name}` has no external store with that name: {store}')
+                    raise excs.Error(f'Table `{self._name}` has no external store with that name: {store}')
 
         for store in stores:
             self._tbl_version.unlink_external_store(store, delete_external_data=delete_external_data)
-            print(f'Unlinked external store from table `{self.name}`: {store}')
+            print(f'Unlinked external store from table `{self._name}`: {store}')
 
     def sync(
             self,
@@ -949,7 +932,7 @@ class Table(SchemaObject):
 
         for store in stores:
             if store not in all_stores:
-                raise excs.Error(f'Table `{self.name}` has no external store with that name: {store}')
+                raise excs.Error(f'Table `{self._name}` has no external store with that name: {store}')
 
         from pixeltable.io import SyncStatus
 
@@ -962,7 +945,7 @@ class Table(SchemaObject):
         return sync_status
 
     def __dir__(self) -> list[str]:
-        return list(super().__dir__()) + self.column_names() + self.query_names()
+        return list(super().__dir__()) + list(self._schema.keys()) + self._query_names
 
     def _ipython_key_completions_(self) -> list[str]:
-        return self.column_names() + self.query_names()
+        return list(self._schema.keys()) + self._query_names

pixeltable/catalog/table_version.py

@@ -12,7 +12,7 @@ from uuid import UUID
 import sqlalchemy as sql
 import sqlalchemy.orm as orm
 
-import pixeltable
+import pixeltable as pxt
 import pixeltable.exceptions as excs
 import pixeltable.exprs as exprs
 import pixeltable.func as func
@@ -24,7 +24,7 @@ from pixeltable.metadata import schema
 from pixeltable.utils.filecache import FileCache
 from pixeltable.utils.media_store import MediaStore
 from .column import Column
-from .globals import UpdateStatus, POS_COLUMN_NAME, is_valid_identifier, _ROWID_COLUMN_NAME
+from .globals import UpdateStatus, _POS_COLUMN_NAME, is_valid_identifier, _ROWID_COLUMN_NAME
 from ..func.globals import resolve_symbol
 
 _logger = logging.getLogger('pixeltable')
@@ -56,7 +56,7 @@ class TableVersion:
 
     def __init__(
             self, id: UUID, tbl_md: schema.TableMd, version: int, schema_version_md: schema.TableSchemaVersionMd,
-            base: Optional[TableVersion] = None, base_path: Optional['pixeltable.catalog.TableVersionPath'] = None,
+            base: Optional[TableVersion] = None, base_path: Optional['pxt.catalog.TableVersionPath'] = None,
             is_snapshot: Optional[bool] = None
     ):
         # only one of base and base_path can be non-None
@@ -124,7 +124,7 @@ class TableVersion:
         self.cols_by_id: dict[int, Column] = {}  # contains only columns visible in this version, both system and user
         self.idx_md = tbl_md.index_md  # needed for _create_tbl_md()
         self.idxs_by_name: dict[str, TableVersion.IndexInfo] = {}  # contains only actively maintained indices
-        self.external_stores: dict[str, pixeltable.io.ExternalStore] = {}
+        self.external_stores: dict[str, pxt.io.ExternalStore] = {}
 
         self._init_schema(tbl_md, schema_version_md)
 
@@ -145,7 +145,7 @@ class TableVersion:
     @classmethod
     def create(
             cls, session: orm.Session, dir_id: UUID, name: str, cols: List[Column], num_retained_versions: int,
-            comment: str, base_path: Optional['pixeltable.catalog.TableVersionPath'] = None,
+            comment: str, base_path: Optional['pxt.catalog.TableVersionPath'] = None,
             view_md: Optional[schema.ViewMd] = None
     ) -> Tuple[UUID, Optional[TableVersion]]:
         # assign ids
@@ -636,14 +636,28 @@ class TableVersion:
         _logger.info(f'[{self.name}] Updating table schema to version: {self.version}')
 
     def insert(
-            self, rows: List[Dict[str, Any]], print_stats: bool = False, fail_on_exception : bool = True
+            self,
+            rows: Optional[list[dict[str, Any]]],
+            df: Optional[pxt.DataFrame],
+            conn: Optional[sql.engine.Connection] = None,
+            print_stats: bool = False,
+            fail_on_exception: bool = True
     ) -> UpdateStatus:
-        """Insert rows into this table.
         """
-        assert self.is_insertable()
+        Insert rows into this table, either from an explicit list of dicts or from a `DataFrame`.
+        """
         from pixeltable.plan import Planner
-        plan = Planner.create_insert_plan(self, rows, ignore_errors=not fail_on_exception)
-        with Env.get().engine.begin() as conn:
+
+        assert self.is_insertable()
+        assert (rows is None) != (df is None)  # Exactly one must be specified
+        if rows is not None:
+            plan = Planner.create_insert_plan(self, rows, ignore_errors=not fail_on_exception)
+        else:
+            plan = Planner.create_df_insert_plan(self, df, ignore_errors=not fail_on_exception)
+        if conn is None:
+            with Env.get().engine.begin() as conn:
+                return self._insert(plan, conn, time.time(), print_stats)
+        else:
             return self._insert(plan, conn, time.time(), print_stats)
 
     def _insert(
@@ -739,7 +753,7 @@ class TableVersion:
                 if error_if_not_exists:
                     raise excs.Error(f'batch_update(): {len(unmatched_rows)} row(s) not found')
                 if insert_if_not_exists:
-                    insert_status = self.insert(unmatched_rows, print_stats=False, fail_on_exception=False)
+                    insert_status = self.insert(unmatched_rows, None, print_stats=False, fail_on_exception=False)
                     result += insert_status
             return result
 
@@ -994,11 +1008,11 @@ class TableVersion:
     def _init_external_stores(self, tbl_md: schema.TableMd) -> None:
         for store_md in tbl_md.external_stores:
             store_cls = resolve_symbol(store_md['class'])
-            assert isinstance(store_cls, type) and issubclass(store_cls, pixeltable.io.ExternalStore)
+            assert isinstance(store_cls, type) and issubclass(store_cls, pxt.io.ExternalStore)
             store = store_cls.from_dict(store_md['md'])
             self.external_stores[store.name] = store
 
-    def link_external_store(self, store: pixeltable.io.ExternalStore) -> None:
+    def link_external_store(self, store: pxt.io.ExternalStore) -> None:
         with Env.get().engine.begin() as conn:
             store.link(self, conn)  # May result in additional metadata changes
             self.external_stores[store.name] = store
@@ -1012,7 +1026,7 @@ class TableVersion:
             del self.external_stores[store_name]
             self._update_md(time.time(), conn, update_tbl_version=False)
 
-        if delete_external_data and isinstance(store, pixeltable.io.external_store.Project):
+        if delete_external_data and isinstance(store, pxt.io.external_store.Project):
             store.delete()
 
     def is_view(self) -> bool:
@@ -1032,7 +1046,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():
+        if col.name == _POS_COLUMN_NAME and self.is_component_view():
             return True
         return False
 
@@ -1056,7 +1070,7 @@ class TableVersion:
         return names
 
     @classmethod
-    def _create_value_expr(cls, col: Column, path: 'pixeltable.catalog.TableVersionPath') -> None:
+    def _create_value_expr(cls, col: Column, path: 'pxt.catalog.TableVersionPath') -> None:
         """
         Create col.value_expr, given col.compute_func.
         Interprets compute_func's parameters to be references to columns and construct ColumnRefs as args.
@@ -1093,16 +1107,13 @@ class TableVersion:
         result = {info.val_col for col in cols for info in col.get_idx_info().values()}
         return result
 
-    def get_dependent_columns(self, cols: list[Column]) -> set[Column]:
+    def get_dependent_columns(self, cols: Iterable[Column]) -> set[Column]:
         """
         Return the set of columns that transitively depend on any of the given ones.
         """
-        if len(cols) == 0:
-            return set()
-        result: set[Column] = set()
-        for col in cols:
-            result.update(col.dependent_cols)
-        result.update(self.get_dependent_columns(result))
+        result = {dependent_col for col in cols for dependent_col in col.dependent_cols}
+        if len(result) > 0:
+            result.update(self.get_dependent_columns(result))
         return result
 
     def num_rowid_columns(self) -> int:
@@ -1123,7 +1134,7 @@ class TableVersion:
         return column_md
 
     @classmethod
-    def _create_stores_md(cls, stores: Iterable['pixeltable.io.ExternalStore']) -> list[dict[str, Any]]:
+    def _create_stores_md(cls, stores: Iterable['pxt.io.ExternalStore']) -> list[dict[str, Any]]:
         return [
             {
                 'class': f'{type(store).__module__}.{type(store).__qualname__}',

pixeltable/catalog/table_version_path.py

@@ -6,7 +6,7 @@ from uuid import UUID
 
 import pixeltable
 from .column import Column
-from .globals import POS_COLUMN_NAME
+from .globals import _POS_COLUMN_NAME
 from .table_version import TableVersion
 
 _logger = logging.getLogger('pixeltable')
@@ -83,7 +83,7 @@ class TableVersionPath:
     def __getattr__(self, col_name: str) -> 'pixeltable.exprs.ColumnRef':
         """Return a ColumnRef for the given column name."""
         from pixeltable.exprs import ColumnRef, RowidRef
-        if col_name == POS_COLUMN_NAME and self.is_component_view():
+        if col_name == _POS_COLUMN_NAME and self.is_component_view():
             return RowidRef(self.tbl_version, self.tbl_version.store_tbl.pos_col_idx)
         if col_name not in self.tbl_version.cols_by_name:
             if self.base is None:

pixeltable/catalog/view.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import inspect
 import logging
-from typing import Optional, Type, Dict, Set, Any, Iterable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Set, Type
 from uuid import UUID
 
 import sqlalchemy.orm as orm
@@ -14,10 +14,11 @@ import pixeltable.metadata.schema as md_schema
 from pixeltable.env import Env
 from pixeltable.exceptions import Error
 from pixeltable.iterators import ComponentIterator
-from pixeltable.type_system import InvalidType, IntType
+from pixeltable.type_system import IntType, InvalidType
+
 from .catalog import Catalog
 from .column import Column
-from .globals import POS_COLUMN_NAME, UpdateStatus
+from .globals import _POS_COLUMN_NAME, UpdateStatus
 from .table import Table
 from .table_version import TableVersion
 from .table_version_path import TableVersionPath
@@ -45,11 +46,11 @@ class View(Table):
         self._snapshot_only = snapshot_only
 
     @classmethod
-    def display_name(cls) -> str:
+    def _display_name(cls) -> str:
         return 'view'
 
     @classmethod
-    def create(
+    def _create(
             cls, dir_id: UUID, name: str, base: TableVersionPath, schema: Dict[str, Any],
             predicate: 'pxt.exprs.Expr', is_snapshot: bool, num_retained_versions: int, comment: str,
             iterator_cls: Optional[Type[ComponentIterator]], iterator_args: Optional[Dict]
@@ -100,7 +101,7 @@ class View(Table):
             # a component view exposes the pos column of its rowid;
             # we create that column here, so it gets assigned a column id;
             # stored=False: it is not stored separately (it's already stored as part of the rowid)
-            iterator_cols = [Column(POS_COLUMN_NAME, IntType(), stored=False)]
+            iterator_cols = [Column(_POS_COLUMN_NAME, IntType(), stored=False)]
             output_dict, unstored_cols = iterator_cls.output_schema(**bound_args)
             iterator_cols.extend([
                 Column(col_name, col_type, stored=col_name not in unstored_cols)
@@ -207,11 +208,17 @@ class View(Table):
         cat.tbl_dependents[self._base_id].remove(self)
         del cat.tbl_dependents[self._id]
 
+    def get_metadata(self) -> dict[str, Any]:
+        md = super().get_metadata()
+        md['is_view'] = True
+        md['is_snapshot'] = self._tbl_version_path.is_snapshot()
+        return md
+
     def insert(
             self, rows: Optional[Iterable[dict[str, Any]]] = None, /, *, print_stats: bool = False,
             fail_on_exception: bool = True, **kwargs: Any
     ) -> UpdateStatus:
-        raise excs.Error(f'{self.display_name()} {self._name!r}: cannot insert into view')
+        raise excs.Error(f'{self._display_name()} {self._name!r}: cannot insert into view')
 
     def delete(self, where: Optional['pixeltable.exprs.Expr'] = None) -> UpdateStatus:
-        raise excs.Error(f'{self.display_name()} {self._name!r}: cannot delete from view')
+        raise excs.Error(f'{self._display_name()} {self._name!r}: cannot delete from view')