pixeltable 0.2.10__py3-none-any.whl → 0.2.11__py3-none-any.whl

pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.2.10"
-__version_tuple__ = (0, 2, 10)
+__version__ = "0.2.11"
+__version_tuple__ = (0, 2, 11)

pixeltable/catalog/catalog.py

@@ -120,7 +120,7 @@ class Catalog:
                     base = base_version
                 assert base_path is not None
 
-                base_tbl = self.tbls[base_path.tbl_version.id]
+                base_tbl_id = base_path.tbl_id()
                 is_snapshot = view_md is not None and view_md.is_snapshot
                 snapshot_only = is_snapshot and view_md.predicate is None and len(schema_version_md.columns) == 0
                 if snapshot_only:
@@ -134,9 +134,9 @@ class Catalog:
                     view_path = TableVersionPath(tbl_version, base=base_path)
 
                 tbl = View(
-                    tbl_record.id, tbl_record.dir_id, tbl_md.name, view_path, base_tbl,
+                    tbl_record.id, tbl_record.dir_id, tbl_md.name, view_path, base_tbl_id,
                     snapshot_only=snapshot_only)
-                self.tbl_dependents[base_tbl._id].append(tbl)
+                self.tbl_dependents[base_tbl_id].append(tbl)
 
             else:
                 tbl_version = TableVersion(tbl_record.id, tbl_md, tbl_md.current_version, schema_version_md)

pixeltable/catalog/globals.py

@@ -7,6 +7,8 @@ _logger = logging.getLogger('pixeltable')
 
 # name of the position column in a component view
 POS_COLUMN_NAME = 'pos'
+_ROWID_COLUMN_NAME = '_rowid'
+
 
 @dataclasses.dataclass
 class UpdateStatus:

pixeltable/catalog/insertable_table.py

@@ -144,14 +144,4 @@ class InsertableTable(Table):
 
             >>> tbl.delete(tbl.a > 5)
         """
-        from pixeltable.exprs import Predicate
-        from pixeltable.plan import Planner
-        if where is not None:
-            if not isinstance(where, Predicate):
-                raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
-            analysis_info = Planner.analyze(self._tbl_version_path, where)
-            # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
-            if analysis_info.filter is not None:
-                raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')
-
-        return self.tbl_version.delete(where)
+        return self._tbl_version.delete(where=where)

pixeltable/catalog/table.py

@@ -19,7 +19,7 @@ import pixeltable.index as index
 import pixeltable.metadata.schema as schema
 import pixeltable.type_system as ts
 from .column import Column
-from .globals import is_valid_identifier, is_system_column_name, UpdateStatus
+from .globals import _ROWID_COLUMN_NAME, is_valid_identifier, is_system_column_name, UpdateStatus
 from .schema_object import SchemaObject
 from .table_version import TableVersion
 from .table_version_path import TableVersionPath
@@ -29,8 +29,6 @@ _logger = logging.getLogger('pixeltable')
 class Table(SchemaObject):
     """Base class for all tabular SchemaObjects."""
 
-    __ROWID_COLUMN_NAME = '_rowid'
-
     def __init__(self, id: UUID, dir_id: UUID, name: str, tbl_version_path: TableVersionPath):
         super().__init__(id, name, dir_id)
         self._is_dropped = False
@@ -93,7 +91,7 @@ class Table(SchemaObject):
         else:
             return catalog.Catalog.get().tbl_dependents[self._get_id()]
 
-    def df(self) -> 'pixeltable.dataframe.DataFrame':
+    def _df(self) -> 'pixeltable.dataframe.DataFrame':
         """Return a DataFrame for this table.
         """
         # local import: avoid circular imports
@@ -132,30 +130,30 @@ class Table(SchemaObject):
 
     def collect(self) -> 'pixeltable.dataframe.DataFrameResultSet':
         """Return rows from this table."""
-        return self.df().collect()
+        return self._df().collect()
 
     def show(
             self, *args, **kwargs
     ) -> 'pixeltable.dataframe.DataFrameResultSet':
         """Return rows from this table.
         """
-        return self.df().show(*args, **kwargs)
+        return self._df().show(*args, **kwargs)
 
     def head(
             self, *args, **kwargs
     ) -> 'pixeltable.dataframe.DataFrameResultSet':
         """Return the first n rows inserted into this table."""
-        return self.df().head(*args, **kwargs)
+        return self._df().head(*args, **kwargs)
 
     def tail(
             self, *args, **kwargs
     ) -> 'pixeltable.dataframe.DataFrameResultSet':
         """Return the last n rows inserted into this table."""
-        return self.df().tail(*args, **kwargs)
+        return self._df().tail(*args, **kwargs)
 
     def count(self) -> int:
         """Return the number of rows in this table."""
-        return self.df().count()
+        return self._df().count()
 
     def column_names(self) -> list[str]:
         """Return the names of the columns in this table."""
@@ -706,21 +704,8 @@ class Table(SchemaObject):
 
             >>> tbl.update({'int_col': tbl.int_col + 1}, where=tbl.int_col == 0)
         """
-        if self._tbl_version_path.is_snapshot():
-            raise excs.Error('Cannot update a snapshot')
         self._check_is_dropped()
-
-        update_spec = self._validate_update_spec(value_spec, allow_pk=False, allow_exprs=True)
-        from pixeltable.plan import Planner
-        if where is not None:
-            if not isinstance(where, exprs.Predicate):
-                raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
-            analysis_info = Planner.analyze(self._tbl_version_path, where)
-            # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
-            if analysis_info.filter is not None:
-                raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')
-
-        return self._tbl_version.update(update_spec, where, cascade)
+        return self._tbl_version.update(value_spec, where, cascade)
 
     def batch_update(self, rows: Iterable[dict[str, Any]], cascade: bool = True) -> UpdateStatus:
         """Update rows in this table.
@@ -738,22 +723,23 @@ class Table(SchemaObject):
         if self._tbl_version_path.is_snapshot():
             raise excs.Error('Cannot update a snapshot')
         self._check_is_dropped()
+        rows = list(rows)
 
         row_updates: list[dict[Column, exprs.Expr]] = []
         pk_col_names = set(c.name for c in self._tbl_version.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 = self.__ROWID_COLUMN_NAME in rows[0]
+        has_rowid = _ROWID_COLUMN_NAME in rows[0]
         rowids: list[Tuple[int, ...]] = []
         if len(pk_col_names) == 0 and not has_rowid:
             raise excs.Error('Table must have primary key for batch update')
 
         for row_spec in rows:
-            col_vals = self._validate_update_spec(row_spec, allow_pk=not has_rowid, allow_exprs=False)
+            col_vals = self._tbl_version._validate_update_spec(row_spec, allow_pk=not has_rowid, allow_exprs=False)
             if has_rowid:
                 # we expect the _rowid column to be present for each row
-                assert self.__ROWID_COLUMN_NAME in row_spec
-                rowids.append(row_spec[self.__ROWID_COLUMN_NAME])
+                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())
                 if any(pk_col_name not in col_names for pk_col_name in pk_col_names):
@@ -762,51 +748,6 @@ class Table(SchemaObject):
             row_updates.append(col_vals)
         return self._tbl_version.batch_update(row_updates, rowids, cascade)
 
-    def _validate_update_spec(
-            self, value_spec: dict[str, Any], allow_pk: bool, allow_exprs: bool
-    ) -> dict[Column, 'pixeltable.exprs.Expr']:
-        from pixeltable import exprs
-        update_targets: dict[Column, exprs.Expr] = {}
-        for col_name, val in value_spec.items():
-            if not isinstance(col_name, str):
-                raise excs.Error(f'Update specification: dict key must be column name, got {col_name!r}')
-            if col_name == self.__ROWID_COLUMN_NAME:
-                # ignore pseudo-column _rowid
-                continue
-            col = self._tbl_version_path.get_column(col_name, include_bases=False)
-            if col is None:
-                # TODO: return more informative error if this is trying to update a base column
-                raise excs.Error(f'Column {col_name} unknown')
-            if col.is_computed:
-                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():
-                raise excs.Error(f'Column {col_name} has type image/video/audio/document and cannot be updated')
-
-            # make sure that the value is compatible with the column type
-            try:
-                # check if this is a literal
-                value_expr = exprs.Literal(val, col_type=col.col_type)
-            except TypeError:
-                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})')
-                # 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')
-                if not col.col_type.matches(value_expr.col_type):
-                    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})'
-                    ))
-            update_targets[col] = value_expr
-
-        return update_targets
-
-    @abc.abstractmethod
     def delete(self, where: Optional['pixeltable.exprs.Predicate'] = None) -> UpdateStatus:
         """Delete rows in this table.
 

pixeltable/catalog/table_version.py

@@ -5,29 +5,31 @@ import importlib
 import inspect
 import logging
 import time
-from typing import Optional, List, Dict, Any, Tuple, Type, Set, Iterable
 import uuid
+from typing import Optional, List, Dict, Any, Tuple, Type, Iterable
 from uuid import UUID
 
 import sqlalchemy as sql
 import sqlalchemy.orm as orm
 
 import pixeltable
-import pixeltable.func as func
-import pixeltable.type_system as ts
 import pixeltable.exceptions as excs
+import pixeltable.exprs as exprs
+import pixeltable.func as func
 import pixeltable.index as index
+import pixeltable.type_system as ts
 from pixeltable.env import Env
 from pixeltable.iterators import ComponentIterator
 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
+from .globals import UpdateStatus, POS_COLUMN_NAME, is_valid_identifier, _ROWID_COLUMN_NAME
 from ..func.globals import resolve_symbol
 
 _logger = logging.getLogger('pixeltable')
 
+
 class TableVersion:
     """
     TableVersion represents a particular version of a table/view along with its physical representation:
@@ -243,7 +245,6 @@ class TableVersion:
     def _init_cols(self, tbl_md: schema.TableMd, schema_version_md: schema.TableSchemaVersionMd) -> None:
         """Initialize self.cols with the columns visible in our effective version"""
         import pixeltable.exprs as exprs
-        from pixeltable.catalog import Catalog
 
         self.cols = []
         self.cols_by_name = {}
@@ -704,15 +705,34 @@ class TableVersion:
         return result
 
     def update(
-            self, update_targets: dict[Column, 'pixeltable.exprs.Expr'],
-            where_clause: Optional['pixeltable.exprs.Predicate'] = None, cascade: bool = True
+        self, value_spec: dict[str, Any], where: Optional['exprs.Predicate'] = None, cascade: bool = True
     ) -> UpdateStatus:
+        """Update rows in this TableVersionPath.
+        Args:
+            value_spec: a list of (column, value) pairs specifying the columns to update and their new values.
+            where: a Predicate to filter rows to update.
+            cascade: if True, also update all computed columns that transitively depend on the updated columns,
+                including within views.
+        """
+        if self.is_snapshot:
+            raise excs.Error('Cannot update a snapshot')
+
+        from pixeltable.plan import Planner
+
+        update_spec = self._validate_update_spec(value_spec, allow_pk=False, allow_exprs=True)
+        if where is not None:
+            if not isinstance(where, exprs.Predicate):
+                raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
+            analysis_info = Planner.analyze(self.path, where)
+            # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
+            if analysis_info.filter is not None:
+                raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')
+
         with Env.get().engine.begin() as conn:
-            return self._update(conn, update_targets, where_clause, cascade)
+            return self._update(conn, update_spec, where, cascade)
 
     def batch_update(
-            self, batch: list[dict[Column, 'pixeltable.exprs.Expr']], rowids: list[Tuple[int, ...]],
-            cascade: bool = True
+            self, batch: list[dict[Column, 'exprs.Expr']], rowids: list[tuple[int, ...]], cascade: bool = True
     ) -> UpdateStatus:
         """Update rows in batch.
         Args:
@@ -721,7 +741,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)
-        import pixeltable.exprs as exprs
         result_status = UpdateStatus()
         cols_with_excs: set[str] = set()
         updated_cols: set[str] = set()
@@ -768,24 +787,61 @@ class TableVersion:
             where_clause: Optional['pixeltable.exprs.Predicate'] = None, cascade: bool = True,
             show_progress: bool = True
     ) -> UpdateStatus:
-        """Update rows in this table.
-        Args:
-            update_targets: a list of (column, value) pairs specifying the columns to update and their new values.
-            where_clause: a Predicate to filter rows to update.
-            cascade: if True, also update all computed columns that transitively depend on the updated columns,
-                including within views.
-        """
-        assert not self.is_snapshot
         from pixeltable.plan import Planner
-        plan, updated_cols, recomputed_cols = \
+
+        plan, updated_cols, recomputed_cols = (
             Planner.create_update_plan(self.path, update_targets, [], where_clause, cascade)
-        result = self._propagate_update(
+        )
+        result = self.propagate_update(
             plan, where_clause.sql_expr() if where_clause is not None else None, recomputed_cols,
             base_versions=[], conn=conn, timestamp=time.time(), cascade=cascade, show_progress=show_progress)
         result.updated_cols = updated_cols
         return result
 
-    def _propagate_update(
+    def _validate_update_spec(
+            self, value_spec: dict[str, Any], allow_pk: bool, allow_exprs: bool
+    ) -> dict[Column, 'exprs.Expr']:
+        update_targets: dict[Column, exprs.Expr] = {}
+        for col_name, val in value_spec.items():
+            if not isinstance(col_name, str):
+                raise excs.Error(f'Update specification: dict key must be column name, got {col_name!r}')
+            if col_name == _ROWID_COLUMN_NAME:
+                # ignore pseudo-column _rowid
+                continue
+            col = self.path.get_column(col_name, include_bases=False)
+            if col is None:
+                # TODO: return more informative error if this is trying to update a base column
+                raise excs.Error(f'Column {col_name} unknown')
+            if col.is_computed:
+                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():
+                raise excs.Error(f'Column {col_name} has type image/video/audio/document and cannot be updated')
+
+            # make sure that the value is compatible with the column type
+            try:
+                # check if this is a literal
+                value_expr = exprs.Literal(val, col_type=col.col_type)
+            except TypeError:
+                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})')
+                # 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')
+                if not col.col_type.matches(value_expr.col_type):
+                    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})'
+                    ))
+            update_targets[col] = value_expr
+
+        return update_targets
+
+    def propagate_update(
             self, plan: Optional[exec.ExecNode], where_clause: Optional[sql.ClauseElement],
             recomputed_view_cols: List[Column], base_versions: List[Optional[int]], conn: sql.engine.Connection,
             timestamp: float, cascade: bool, show_progress: bool = True
@@ -810,7 +866,7 @@ class TableVersion:
                 if len(recomputed_cols) > 0:
                     from pixeltable.plan import Planner
                     plan = Planner.create_view_update_plan(view.path, recompute_targets=recomputed_cols)
-                status = view._propagate_update(
+                status = view.propagate_update(
                     plan, None, recomputed_view_cols, base_versions=base_versions, conn=conn, timestamp=timestamp, cascade=True)
                 result.num_rows += status.num_rows
                 result.num_excs += status.num_excs
@@ -819,22 +875,31 @@ class TableVersion:
         result.cols_with_excs = list(dict.fromkeys(result.cols_with_excs).keys())  # remove duplicates
         return result
 
-    def delete(self, where: Optional['pixeltable.exprs.Predicate'] = None) -> UpdateStatus:
+    def delete(self, where: Optional['exprs.Predicate'] = None) -> UpdateStatus:
         """Delete rows in this table.
         Args:
             where: a Predicate to filter rows to delete.
         """
         assert self.is_insertable()
+        from pixeltable.exprs import Predicate
         from pixeltable.plan import Planner
-        analysis_info = Planner.analyze(self, where)
+        if where is not None:
+            if not isinstance(where, Predicate):
+                raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
+            analysis_info = Planner.analyze(self.path, where)
+            # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
+            if analysis_info.filter is not None:
+                raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')
+
+        analysis_info = Planner.analyze(self.path, where)
         with Env.get().engine.begin() as conn:
-            num_rows = self._delete(analysis_info.sql_where_clause, base_versions=[], conn=conn, timestamp=time.time())
+            num_rows = self.propagate_delete(analysis_info.sql_where_clause, base_versions=[], conn=conn, timestamp=time.time())
 
         status = UpdateStatus(num_rows=num_rows)
         return status
 
-    def _delete(
-            self, where: Optional['pixeltable.exprs.Predicate'], base_versions: List[Optional[int]],
+    def propagate_delete(
+            self, where: Optional['exprs.Predicate'], base_versions: List[Optional[int]],
             conn: sql.engine.Connection, timestamp: float) -> int:
         """Delete rows in this table and propagate to views.
         Args:
@@ -853,7 +918,7 @@ class TableVersion:
         else:
             pass
         for view in self.mutable_views:
-            num_rows += view._delete(
+            num_rows += view.propagate_delete(
                 where=None, base_versions=[self.version] + base_versions, conn=conn, timestamp=timestamp)
         return num_rows
 

pixeltable/catalog/table_version_path.py

@@ -5,13 +5,13 @@ from typing import Optional, Union
 from uuid import UUID
 
 import pixeltable
-import pixeltable.catalog as catalog
 from .column import Column
 from .globals import POS_COLUMN_NAME
 from .table_version import TableVersion
 
 _logger = logging.getLogger('pixeltable')
 
+
 class TableVersionPath:
     """
     A TableVersionPath represents the sequence of TableVersions from a base table to a particular view:

pixeltable/catalog/view.py

@@ -1,30 +1,33 @@
 from __future__ import annotations
+
+import inspect
 import logging
-from typing import List, Optional, Type, Dict, Set, Any, Iterable
+from typing import Optional, Type, Dict, Set, Any, Iterable, TYPE_CHECKING
 from uuid import UUID
-import inspect
 
 import sqlalchemy.orm as orm
 
-from .table import Table
-from .table_version import TableVersion
-from .table_version_path import TableVersionPath
-from .column import Column
-from .catalog import Catalog
-from .globals import POS_COLUMN_NAME, UpdateStatus
-from pixeltable.env import Env
-from pixeltable.iterators import ComponentIterator
-from pixeltable.exceptions import Error
-import pixeltable.func as func
-import pixeltable.type_system as ts
 import pixeltable.catalog as catalog
+import pixeltable.exceptions as excs
+import pixeltable.func as func
 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
-import pixeltable.exceptions as excs
+from .catalog import Catalog
+from .column import Column
+from .globals import POS_COLUMN_NAME, UpdateStatus
+from .table import Table
+from .table_version import TableVersion
+from .table_version_path import TableVersionPath
 
+if TYPE_CHECKING:
+    import pixeltable as pxt
 
 _logger = logging.getLogger('pixeltable')
 
+
 class View(Table):
     """A `Table` that presents a virtual view of another table (or view).
 
@@ -34,10 +37,11 @@ class View(Table):
     is simply a reference to a specific set of base versions.
     """
     def __init__(
-            self, id: UUID, dir_id: UUID, name: str, tbl_version_path: TableVersionPath, base: Table,
+            self, id: UUID, dir_id: UUID, name: str, tbl_version_path: TableVersionPath, base_id: UUID,
             snapshot_only: bool):
         super().__init__(id, dir_id, name, tbl_version_path)
-        self._base = base  # keep a reference to the base Table, so that we can keep track of its dependents
+        assert base_id in catalog.Catalog.get().tbl_dependents
+        self._base_id = base_id  # keep a reference to the base Table ID, so that we can keep track of its dependents
         self._snapshot_only = snapshot_only
 
     @classmethod
@@ -46,8 +50,8 @@ class View(Table):
 
     @classmethod
     def create(
-            cls, dir_id: UUID, name: str, base: Table, schema: Dict[str, Any],
-            predicate: 'exprs.Predicate', is_snapshot: bool, num_retained_versions: int, comment: str,
+            cls, dir_id: UUID, name: str, base: TableVersionPath, schema: Dict[str, Any],
+            predicate: 'pxt.exprs.Predicate', is_snapshot: bool, num_retained_versions: int, comment: str,
             iterator_cls: Optional[Type[ComponentIterator]], iterator_args: Optional[Dict]
     ) -> View:
         columns = cls._create_columns(schema)
@@ -55,8 +59,8 @@ class View(Table):
 
         # verify that filter can be evaluated in the context of the base
         if predicate is not None:
-            if not predicate.is_bound_by(base._tbl_version_path):
-                raise excs.Error(f'Filter cannot be computed in the context of the base {base._name}')
+            if not predicate.is_bound_by(base):
+                raise excs.Error(f'Filter cannot be computed in the context of the base {base.tbl_name()}')
             # create a copy that we can modify and store
             predicate = predicate.copy()
 
@@ -65,9 +69,9 @@ class View(Table):
             if not col.is_computed:
                 continue
             # 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._tbl_version_path):
+            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._name}')
+                    f'Column {col.name}: value expression cannot be computed in the context of the base {base.tbl_name()}')
 
         if iterator_cls is not None:
             assert iterator_args is not None
@@ -114,7 +118,7 @@ class View(Table):
             iterator_args_expr = InlineDict(iterator_args) if iterator_args is not None else None
             iterator_class_fqn = f'{iterator_cls.__module__}.{iterator_cls.__name__}' if iterator_cls is not None \
                 else None
-            base_version_path = cls._get_snapshot_path(base._tbl_version_path) if is_snapshot else base._tbl_version_path
+            base_version_path = cls._get_snapshot_path(base) if is_snapshot else base
             base_versions = [
                 (tbl_version.id.hex, tbl_version.version if is_snapshot or tbl_version.is_snapshot else None)
                 for tbl_version in base_version_path.get_tbl_versions()
@@ -139,11 +143,11 @@ class View(Table):
                 session, dir_id, name, columns, num_retained_versions, comment, base_path=base_version_path, view_md=view_md)
             if tbl_version is None:
                 # this is purely a snapshot: we use the base's tbl version path
-                view = cls(id, dir_id, name, base_version_path, base, snapshot_only=True)
+                view = cls(id, dir_id, name, base_version_path, base.tbl_id(), snapshot_only=True)
                 _logger.info(f'created snapshot {name}')
             else:
                 view = cls(
-                    id, dir_id, name, TableVersionPath(tbl_version, base=base_version_path), base,
+                    id, dir_id, name, TableVersionPath(tbl_version, base=base_version_path), base.tbl_id(),
                     snapshot_only=False)
                 _logger.info(f'Created view `{name}`, id={tbl_version.id}')
 
@@ -156,7 +160,7 @@ class View(Table):
             session.commit()
             cat = Catalog.get()
             cat.tbl_dependents[view._id] = []
-            cat.tbl_dependents[base._id].append(view)
+            cat.tbl_dependents[base.tbl_id()].append(view)
             cat.tbls[view._id] = view
             return view
 
@@ -200,7 +204,7 @@ class View(Table):
             del cat.tbls[self._id]
         else:
             super()._drop()
-        cat.tbl_dependents[self._base._id].remove(self)
+        cat.tbl_dependents[self._base_id].remove(self)
         del cat.tbl_dependents[self._id]
 
     def insert(

pixeltable/dataframe.py

@@ -1,32 +1,27 @@
 from __future__ import annotations
 
-import base64
 import copy
 import hashlib
-import io
 import json
 import logging
 import mimetypes
 import traceback
 from pathlib import Path
-from typing import List, Optional, Any, Dict, Iterator, Tuple, Set
+from typing import List, Optional, Any, Dict, Iterator, Tuple, Set, Callable
 
-import PIL.Image
-import cv2
 import pandas as pd
 import pandas.io.formats.style
 import sqlalchemy as sql
-from PIL import Image
 
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.exprs as exprs
-import pixeltable.type_system as ts
-import pixeltable.func as func
 from pixeltable.catalog import is_valid_identifier
+from pixeltable.catalog.globals import UpdateStatus
 from pixeltable.env import Env
 from pixeltable.plan import Planner
 from pixeltable.type_system import ColumnType
+from pixeltable.utils.formatter import Formatter
 from pixeltable.utils.http_server import get_file_uri
 
 __all__ = ['DataFrame']
@@ -47,12 +42,7 @@ class DataFrameResultSet:
         self._rows = rows
         self._col_names = col_names
         self._col_types = col_types
-        self._formatters = {
-            ts.ImageType: self._format_img,
-            ts.VideoType: self._format_video,
-            ts.AudioType: self._format_audio,
-            ts.DocumentType: self._format_document,
-        }
+        self.__formatter = Formatter(len(self._rows), len(self._col_names), Env.get().http_address)
 
     def __len__(self) -> int:
         return len(self._rows)
@@ -67,11 +57,11 @@ class DataFrameResultSet:
         return self.to_pandas().__repr__()
 
     def _repr_html_(self) -> str:
-        formatters = {
-            col_name: self._formatters[col_type.__class__]
-            for col_name, col_type in zip(self._col_names, self._col_types)
-            if col_type.__class__ in self._formatters
-        }
+        formatters: dict[str, Callable] = {}
+        for col_name, col_type in zip(self._col_names, self._col_types):
+            formatter = self.__formatter.get_pandas_formatter(col_type)
+            if formatter is not None:
+                formatters[col_name] = formatter
         return self.to_pandas().to_html(formatters=formatters, escape=False, index=False)
 
     def __str__(self) -> str:
@@ -87,100 +77,6 @@ class DataFrameResultSet:
     def _row_to_dict(self, row_idx: int) -> Dict[str, Any]:
         return {self._col_names[i]: self._rows[row_idx][i] for i in range(len(self._col_names))}
 
-    # Formatters
-    def _format_img(self, img: Image.Image) -> str:
-        """
-        Create <img> tag for Image object.
-        """
-        assert isinstance(img, Image.Image), f'Wrong type: {type(img)}'
-        # Try to make it look decent in a variety of display scenarios
-        if len(self._rows) > 1:
-            width = 240  # Multiple rows: display small images
-        elif len(self._col_names) > 1:
-            width = 480  # Multiple columns: display medium images
-        else:
-            width = 640  # A single image: larger display
-        with io.BytesIO() as buffer:
-            img.save(buffer, 'jpeg')
-            img_base64 = base64.b64encode(buffer.getvalue()).decode()
-            return f"""
-            <div class="pxt_image" style="width:{width}px;">
-                <img src="data:image/jpeg;base64,{img_base64}" width="{width}" />
-            </div>
-            """
-
-    def _format_video(self, file_path: str) -> str:
-        thumb_tag = ''
-        # Attempt to extract the first frame of the video to use as a thumbnail,
-        # so that the notebook can be exported as HTML and viewed in contexts where
-        # the video itself is not accessible.
-        # TODO(aaron-siegel): If the video is backed by a concrete external URL,
-        # should we link to that instead?
-        video_reader = cv2.VideoCapture(str(file_path))
-        if video_reader.isOpened():
-            status, img_array = video_reader.read()
-            if status:
-                img_array = cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB)
-                thumb = PIL.Image.fromarray(img_array)
-                with io.BytesIO() as buffer:
-                    thumb.save(buffer, 'jpeg')
-                    thumb_base64 = base64.b64encode(buffer.getvalue()).decode()
-                    thumb_tag = f'poster="data:image/jpeg;base64,{thumb_base64}"'
-            video_reader.release()
-        if len(self._rows) > 1:
-            width = 320
-        elif len(self._col_names) > 1:
-            width = 480
-        else:
-            width = 800
-        return f"""
-        <div class="pxt_video" style="width:{width}px;">
-            <video controls width="{width}" {thumb_tag}>
-                {_create_source_tag(file_path)}
-            </video>
-        </div>
-        """
-
-    def _format_document(self, file_path: str) -> str:
-        max_width = max_height = 320
-        # by default, file path will be shown as a link
-        inner_element = file_path
-        # try generating a thumbnail for different types and use that if successful
-        if file_path.lower().endswith('.pdf'):
-            try:
-                import fitz
-
-                doc = fitz.open(file_path)
-                p = doc.get_page_pixmap(0)
-                while p.width > max_width or p.height > max_height:
-                    # shrink(1) will halve each dimension
-                    p.shrink(1)
-                data = p.tobytes(output='jpeg')
-                thumb_base64 = base64.b64encode(data).decode()
-                img_src = f'data:image/jpeg;base64,{thumb_base64}'
-                inner_element = f"""
-                    <img style="object-fit: contain; border: 1px solid black;" src="{img_src}" />
-                """
-            except:
-                logging.warning(f'Failed to produce PDF thumbnail {file_path}. Make sure you have PyMuPDF installed.')
-
-        return f"""
-        <div class="pxt_document" style="width:{max_width}px;">
-            <a href="{get_file_uri(Env.get().http_address, file_path)}">
-                {inner_element}
-            </a>
-        </div>
-        """
-
-    def _format_audio(self, file_path: str) -> str:
-        return f"""
-        <div class="pxt_audio">
-            <audio controls>
-                {_create_source_tag(file_path)}
-            </audio>
-        </div>
-        """
-
     def __getitem__(self, index: Any) -> Any:
         if isinstance(index, str):
             if index not in self._col_names:
@@ -595,7 +491,7 @@ class DataFrame:
                 raise excs.Error(f'Invalid name: {name}')
         base_list = [(expr, None) for expr in items] + [(expr, k) for (k, expr) in named_items.items()]
         if len(base_list) == 0:
-            raise excs.Error(f'Empty select list')
+            return self
 
         # analyze select list; wrap literals with the corresponding expressions
         select_list = []
@@ -708,6 +604,27 @@ class DataFrame:
             limit=n,
         )
 
+    def update(self, value_spec: dict[str, Any], cascade: bool = True) -> UpdateStatus:
+        self._validate_mutable('update')
+        return self.tbl.tbl_version.update(value_spec, where=self.where_clause, cascade=cascade)
+
+    def delete(self) -> UpdateStatus:
+        self._validate_mutable('delete')
+        if not self.tbl.is_insertable():
+            raise excs.Error(f'Cannot delete from view')
+        return self.tbl.tbl_version.delete(where=self.where_clause)
+
+    def _validate_mutable(self, op_name: str) -> None:
+        """Tests whether this `DataFrame` can be mutated (such as by an update operation)."""
+        if self.group_by_clause is not None or self.grouping_tbl is not None:
+            raise excs.Error(f'Cannot use `{op_name}` after `group_by`')
+        if self.order_by_clause is not None:
+            raise excs.Error(f'Cannot use `{op_name}` after `order_by`')
+        if self.select_list is not None:
+            raise excs.Error(f'Cannot use `{op_name}` after `select`')
+        if self.limit_val is not None:
+            raise excs.Error(f'Cannot use `{op_name}` after `limit`')
+
     def __getitem__(self, index: object) -> DataFrame:
         """
         Allowed:

pixeltable/globals.py

@@ -1,13 +1,13 @@
 import dataclasses
 import logging
-from typing import Any, Optional, Union, Type
+from typing import Any, Optional, Union
 
 import pandas as pd
 import sqlalchemy as sql
 from sqlalchemy.util.preloaded import orm
 
 import pixeltable.exceptions as excs
-from pixeltable import catalog, func
+from pixeltable import catalog, func, DataFrame
 from pixeltable.catalog import Catalog
 from pixeltable.env import Env
 from pixeltable.exprs import Predicate
@@ -78,7 +78,7 @@ def create_table(
 
 def create_view(
     path_str: str,
-    base: catalog.Table,
+    base: Union[catalog.Table, DataFrame],
     *,
     schema: Optional[dict[str, Any]] = None,
     filter: Optional[Predicate] = None,
@@ -92,7 +92,7 @@ def create_view(
 
     Args:
         path_str: Path to the view.
-        base: Table (ie, table or view or snapshot) to base the view on.
+        base: Table (i.e., table or view or snapshot) or DataFrame to base the view on.
         schema: dictionary mapping column names to column types, value expressions, or to column specifications.
         filter: Predicate to filter rows of the base table.
         is_snapshot: Whether the view is a snapshot.
@@ -122,7 +122,19 @@ def create_view(
         >>> snapshot_view = cl.create_view(
             'my_snapshot', base, schema={'col3': base.col2 + 1}, filter=base.col1 > 10, is_snapshot=True)
     """
-    assert isinstance(base, catalog.Table)
+    if isinstance(base, catalog.Table):
+        tbl_version_path = base._tbl_version_path
+    elif isinstance(base, DataFrame):
+        base._validate_mutable('create_view')
+        tbl_version_path = base.tbl
+        if base.where_clause is not None and filter is not None:
+            raise excs.Error(
+                'Cannot specify a `filter` directly if one is already declared in a `DataFrame.where` clause'
+            )
+        filter = base.where_clause
+    else:
+        raise excs.Error('`base` must be an instance of `Table` or `DataFrame`')
+    assert isinstance(base, catalog.Table) or isinstance(base, DataFrame)
     path = catalog.Path(path_str)
     try:
         Catalog.get().paths.check_is_valid(path, expected=None)
@@ -139,10 +151,11 @@ def create_view(
         iterator_class, iterator_args = None, None
     else:
         iterator_class, iterator_args = iterator
+
     view = catalog.View.create(
         dir._id,
         path.name,
-        base=base,
+        base=tbl_version_path,
         schema=schema,
         predicate=filter,
         is_snapshot=is_snapshot,

pixeltable/utils/formatter.py

@@ -0,0 +1,234 @@
+import base64
+import html
+import json
+import logging
+import mimetypes
+from typing import Any, Callable, Optional
+
+import PIL
+import PIL.Image as Image
+import cv2
+import numpy as np
+
+import io
+import pixeltable.type_system as ts
+from pixeltable.utils.http_server import get_file_uri
+
+_logger = logging.getLogger('pixeltable')
+
+
+class Formatter:
+    """
+    A factory for constructing HTML formatters for Pixeltable data. The formatters are used to customize
+    the rendering of `DataFrameResultSet`s in notebooks.
+
+    Args:
+        num_rows: Number of rows in the DataFrame being rendered.
+        num_cols: Number of columns in the DataFrame being rendered.
+        http_address: Root address of the Pixeltable HTTP server (used to construct URLs for media references).
+    """
+
+    __FLOAT_PRECISION = 3
+    __LIST_THRESHOLD = 16
+    __LIST_EDGEITEMS = 6
+    __STRING_SEP = ' ...... '
+    __STRING_MAX_LEN = 1000
+    __NESTED_STRING_MAX_LEN = 300
+
+    def __init__(self, num_rows: int, num_cols: int, http_address: str):
+        self.__num_rows = num_rows
+        self.__num_cols = num_cols
+        self.__http_address = http_address
+
+    def get_pandas_formatter(self, col_type: ts.ColumnType) -> Optional[Callable]:
+        if col_type.is_string_type():
+            return self.format_string
+        if col_type.is_float_type():
+            return self.format_float
+        if col_type.is_json_type():
+            return self.format_json
+        if col_type.is_array_type():
+            return self.format_array
+        if col_type.is_image_type():
+            return self.format_img
+        if col_type.is_video_type():
+            return self.format_video
+        if col_type.is_audio_type():
+            return self.format_audio
+        if col_type.is_document_type():
+            return self.format_document
+        return None
+
+    @classmethod
+    def format_string(cls, val: str) -> str:
+        """
+        Escapes special characters in `val`, and abbreviates `val` if its length exceeds `_STRING_MAX_LEN`.
+        """
+        return cls.__escape(cls.__abbreviate(val, cls.__STRING_MAX_LEN))
+
+    @classmethod
+    def __abbreviate(cls, val: str, max_len: int) -> str:
+        if len(val) > max_len:
+            edgeitems = (max_len - len(cls.__STRING_SEP)) // 2
+            return f'{val[:edgeitems]}{cls.__STRING_SEP}{val[-edgeitems:]}'
+        return val
+
+    @classmethod
+    def __escape(cls, val: str) -> str:
+        # HTML-escape the specified string, then escape $ signs to suppress MathJax formatting
+        # TODO(aaron-siegel): The '$' escaping isn't perfect; it will fail on '$' that are already escaped
+        return html.escape(val).replace('$', r'\$')
+
+    @classmethod
+    def format_float(cls, val: float) -> str:
+        # stay consistent with numpy formatting (0-D array has no brackets)
+        return np.array2string(np.array(val), precision=cls.__FLOAT_PRECISION)
+
+    @classmethod
+    def format_array(cls, arr: np.ndarray) -> str:
+        return np.array2string(
+            arr,
+            precision=cls.__FLOAT_PRECISION,
+            threshold=cls.__LIST_THRESHOLD,
+            edgeitems=cls.__LIST_EDGEITEMS,
+            max_line_width=1000000,
+        )
+
+    @classmethod
+    def format_json(cls, val: Any) -> str:
+        if isinstance(val, str):
+            # JSON-like formatting will be applied to strings that appear nested within a list or dict
+            # (quote the string; escape any quotes inside the string; shorter abbreviations).
+            # However, if the string appears in top-level position (i.e., the entire JSON value is a
+            # string), then we format it like an ordinary string.
+            return cls.format_string(val)
+        # In all other cases, dump the JSON struct recursively.
+        return cls.__format_json_rec(val)
+
+    @classmethod
+    def __format_json_rec(cls, val: Any) -> str:
+        if isinstance(val, str):
+            return cls.__escape(json.dumps(cls.__abbreviate(val, cls.__NESTED_STRING_MAX_LEN)))
+        if isinstance(val, float):
+            return cls.format_float(val)
+        if isinstance(val, np.ndarray):
+            return cls.format_array(val)
+        if isinstance(val, list):
+            if len(val) < cls.__LIST_THRESHOLD:
+                components = [cls.__format_json_rec(x) for x in val]
+            else:
+                components = [cls.__format_json_rec(x) for x in val[: cls.__LIST_EDGEITEMS]]
+                components.append('...')
+                components.extend(cls.__format_json_rec(x) for x in val[-cls.__LIST_EDGEITEMS :])
+            return '[' + ', '.join(components) + ']'
+        if isinstance(val, dict):
+            kv_pairs = (f'{cls.__format_json_rec(k)}: {cls.__format_json_rec(v)}' for k, v in val.items())
+            return '{' + ', '.join(kv_pairs) + '}'
+
+        # Everything else
+        try:
+            return json.dumps(val)
+        except TypeError:  # Not JSON serializable
+            return str(val)
+
+    def format_img(self, img: Image.Image) -> str:
+        """
+        Create <img> tag for Image object.
+        """
+        assert isinstance(img, Image.Image), f'Wrong type: {type(img)}'
+        # Try to make it look decent in a variety of display scenarios
+        if self.__num_rows > 1:
+            width = 240  # Multiple rows: display small images
+        elif self.__num_cols > 1:
+            width = 480  # Multiple columns: display medium images
+        else:
+            width = 640  # A single image: larger display
+        with io.BytesIO() as buffer:
+            img.save(buffer, 'jpeg')
+            img_base64 = base64.b64encode(buffer.getvalue()).decode()
+            return f"""
+            <div class="pxt_image" style="width:{width}px;">
+                <img src="data:image/jpeg;base64,{img_base64}" width="{width}" />
+            </div>
+            """
+
+    def format_video(self, file_path: str) -> str:
+        thumb_tag = ''
+        # Attempt to extract the first frame of the video to use as a thumbnail,
+        # so that the notebook can be exported as HTML and viewed in contexts where
+        # the video itself is not accessible.
+        # TODO(aaron-siegel): If the video is backed by a concrete external URL,
+        # should we link to that instead?
+        video_reader = cv2.VideoCapture(str(file_path))
+        if video_reader.isOpened():
+            status, img_array = video_reader.read()
+            if status:
+                img_array = cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB)
+                thumb = PIL.Image.fromarray(img_array)
+                with io.BytesIO() as buffer:
+                    thumb.save(buffer, 'jpeg')
+                    thumb_base64 = base64.b64encode(buffer.getvalue()).decode()
+                    thumb_tag = f'poster="data:image/jpeg;base64,{thumb_base64}"'
+            video_reader.release()
+        if self.__num_rows > 1:
+            width = 320
+        elif self.__num_cols > 1:
+            width = 480
+        else:
+            width = 800
+        return f"""
+        <div class="pxt_video" style="width:{width}px;">
+            <video controls width="{width}" {thumb_tag}>
+                {self.__create_source_tag(self.__http_address, file_path)}
+            </video>
+        </div>
+        """
+
+    def format_audio(self, file_path: str) -> str:
+        return f"""
+        <div class="pxt_audio">
+            <audio controls>
+                {self.__create_source_tag(self.__http_address, file_path)}
+            </audio>
+        </div>
+        """
+
+    def format_document(self, file_path: str) -> str:
+        max_width = max_height = 320
+        # by default, file path will be shown as a link
+        inner_element = file_path
+        inner_element = html.escape(inner_element)
+        # try generating a thumbnail for different types and use that if successful
+        if file_path.lower().endswith('.pdf'):
+            try:
+                import fitz
+
+                doc = fitz.open(file_path)
+                p = doc.get_page_pixmap(0)
+                while p.width > max_width or p.height > max_height:
+                    # shrink(1) will halve each dimension
+                    p.shrink(1)
+                data = p.tobytes(output='jpeg')
+                thumb_base64 = base64.b64encode(data).decode()
+                img_src = f'data:image/jpeg;base64,{thumb_base64}'
+                inner_element = f"""
+                    <img style="object-fit: contain; border: 1px solid black;" src="{img_src}" />
+                """
+            except:
+                logging.warning(f'Failed to produce PDF thumbnail {file_path}. Make sure you have PyMuPDF installed.')
+
+        return f"""
+        <div class="pxt_document" style="width:{max_width}px;">
+            <a href="{get_file_uri(self.__http_address, file_path)}">
+                {inner_element}
+            </a>
+        </div>
+        """
+
+    @classmethod
+    def __create_source_tag(cls, http_address: str, file_path: str) -> str:
+        src_url = get_file_uri(http_address, file_path)
+        mime = mimetypes.guess_type(src_url)[0]
+        # if mime is None, the attribute string would not be valid html.
+        mime_attr = f'type="{mime}"' if mime is not None else ''
+        return f'<source src="{src_url}" {mime_attr} />'

{pixeltable-0.2.10.dist-info → pixeltable-0.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.2.10
+Version: 0.2.11
 Summary: Pixeltable: The Multimodal AI Data Plane
 Author: Marcel Kornacker
 Author-email: marcelk@gmail.com
@@ -75,7 +75,7 @@ Learn how to create tables, populate them with data, and enhance them with built
 
 | Topic      |                                                                                Notebook                                                                                |                                                                                API                                                                                |
 |:--------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------:|
-| Get Started    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/tutorials/pixeltable-basics.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> |                 [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api/pixeltable/)                 |
+| Get Started    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/pixeltable-basics.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> |                 [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api/pixeltable/)                 |
 | User-Defined Functions (UDFs)    | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/howto/udfs-in-pixeltable.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a> |                 [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api/iterators/document-splitter/)                 |
 | Comparing Object Detection Models | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/object-detection-in-videos.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/> </a>            | [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api-cheat-sheet/#frame-extraction-for-video-data) |
 | Experimenting with Chunking (RAG) | <a target="_blank" href="https://colab.research.google.com/github/pixeltable/pixeltable/blob/master/docs/release/tutorials/rag-operations.ipynb"> <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>            | [![API](https://img.shields.io/badge/api-reference-blue.svg)](https://pixeltable.github.io/pixeltable/api/iterators/document-splitter/) |

{pixeltable-0.2.10.dist-info → pixeltable-0.2.11.dist-info}/RECORD

@@ -1,20 +1,20 @@
 pixeltable/__init__.py,sha256=GNlV3jQKDQKTrOq8BVvPsnd9W9ROneP9-1C-zgNSWsg,1275
-pixeltable/__version__.py,sha256=4ON_EBN7M0CO070jZIUauJIAKAL4Ccrf8-Kg_a7aB0w,114
+pixeltable/__version__.py,sha256=EOLZYNHwHWPLWPMk2nm8H1fHHCn1KsQtw2ovnB_eAnY,114
 pixeltable/catalog/__init__.py,sha256=E41bxaPeQIcgRYzTWc2vkDOboQhRymrJf4IcHQO7o_8,453
-pixeltable/catalog/catalog.py,sha256=gzEuse0f_rj7oKRWMyorhUpOLhYbWSQ8CFLOuFLbXak,7918
+pixeltable/catalog/catalog.py,sha256=8gsFWm6o9Qg4_BEO6oejdpmP4MAOlhmuKRaJP0o2UPU,7906
 pixeltable/catalog/column.py,sha256=Dmc6CgFLExJy3tdvuX0Emjc8SgqZvmCbAHozibO1-G0,9417
 pixeltable/catalog/dir.py,sha256=DWl9nnCOoiYLKWp31MNMvLmryXeQiQZu5YJcd4tpy38,921
-pixeltable/catalog/globals.py,sha256=yLEGNbsSnLzjWNHVJacfjA9hbw13Q6QXLOSCRmdTlq0,943
-pixeltable/catalog/insertable_table.py,sha256=jP6EFMqkGNAbqRAj6YpCaZzWdFwu13t_dQste_f0clk,6468
+pixeltable/catalog/globals.py,sha256=tNb_6jzAKJWD4MH1Y9g2UhVQkiomYfbHQZ2GIcg7vUI,974
+pixeltable/catalog/insertable_table.py,sha256=u2yMCw1lWSIeRAknIKQmSMWS_3oLTn1kCR1Hk79OvrI,5883
 pixeltable/catalog/named_function.py,sha256=UhHaimM_uJHS-0RQcqGOgvWeZtMfKsIgSeKSRwT2moU,1149
 pixeltable/catalog/path.py,sha256=QgccEi_QOfaKt8YsR2zLtd_z7z7QQkU_1kprJFi2SPQ,1677
 pixeltable/catalog/path_dict.py,sha256=xfvxg1Ze5jZCARUGASF2DRbQPh7pRVTYhuJ_u82gYUo,5941
 pixeltable/catalog/schema_object.py,sha256=Sf8aGARpsPeRUz1NjsZ97oSBMyElsctP39uU9x9Ic80,964
-pixeltable/catalog/table.py,sha256=qzxm3SN0hHObZlJycEsmzOd3VLsqSnrZ9fk1M3F5YGM,42636
-pixeltable/catalog/table_version.py,sha256=-46Z-aSKdjXpbmWlwZpGWZMw6VOKJZczNvx05Txe_0I,55148
-pixeltable/catalog/table_version_path.py,sha256=lE2EFn0kylXhy-oBXTyXbJox6rl_6klfOmDjK-2Uq_Q,6432
-pixeltable/catalog/view.py,sha256=dphf9ZFi_ReQkokcN_Auh6ZQFmGtnOcVDvz6fcJfJzs,10332
-pixeltable/dataframe.py,sha256=Bws93dh5zeIhwuF-fezV0TWVXxmkISCD0nIh1W0m_Fw,37173
+pixeltable/catalog/table.py,sha256=5CSEASIJqWJ0l1mDERYMqj_5rD--y4F8yhqq3Uu0lAI,39473
+pixeltable/catalog/table_version.py,sha256=JrwwvG1vizCDJ-11GgTwnCg2XSOqyrJ6w2wbqmWYR60,58582
+pixeltable/catalog/table_version_path.py,sha256=6JZlgKMYa3Xf8p_2Z-iDIFIcfuYRyjbpc3_CC9l1HME,6396
+pixeltable/catalog/view.py,sha256=3OAk-NBPlSagMCsdVtcx35jHD80SIYCuOy5dc1kM7Fs,10403
+pixeltable/dataframe.py,sha256=O8tAgOqFa_twjak-hDIBoXB5MZx-ZyzYOCeQr8jCO-0,34339
 pixeltable/env.py,sha256=WO_WLfRj9Fft6QyW89S9cw47RTg1ALviStu9pNygJEQ,21635
 pixeltable/exceptions.py,sha256=MSP9zeL0AmXT93XqjdvgGN4rzno1_KRrGriq6hpemnw,376
 pixeltable/exec/__init__.py,sha256=RK7SKvrQ7Ky3G_LXDP4Bf7lHmMM_uYZl8dJaZYs0FjY,454
@@ -80,7 +80,7 @@ pixeltable/functions/together.py,sha256=2vHOoXMUIpeYwTYGTr3hDHePzy8zepvoeyORgV_9
 pixeltable/functions/util.py,sha256=F2iiIL7UfhYdCVzdCa3efYqWbaeLKFrbycKnuPkG57M,650
 pixeltable/functions/video.py,sha256=yn52MimAVrSzUyAUtyxbd1RWveX_TyjwsomBuhK9V60,6516
 pixeltable/functions/whisper.py,sha256=s7C4eV5tCJed-4Joob5LojGFEHPgapmT8awFPVxBKgQ,2199
-pixeltable/globals.py,sha256=WeIQbN6peyJL3VbIBxtL21p7XKREpDmtZ_MuDEUmOu4,14158
+pixeltable/globals.py,sha256=xSj0pmgmRavmD_-TOFhNXd8slskOC2R95el9L7pyzxM,14795
 pixeltable/index/__init__.py,sha256=XBwetNQQwnz0fiKwonOKhyy_U32l_cjt77kNvEIdjWs,102
 pixeltable/index/base.py,sha256=YAQ5Dz1mfI0dfu9rxWHWroE8TjB90yKfPtXAzoADq38,1568
 pixeltable/index/btree.py,sha256=NE4GYhcJWYJhdKyeHI0sQBlFvUaIgGOF9KLyCZOfFjE,1822
@@ -118,6 +118,7 @@ pixeltable/utils/coco.py,sha256=ISpFBhR4eO1jOcg_SPb0thVI4KdS6H0RyNQauZIA5A4,7287
 pixeltable/utils/code.py,sha256=AOw1u2r8_DQXpX-lxJhyHWARGrCRDXOJHFVgKOi54Uc,1231
 pixeltable/utils/documents.py,sha256=Q7e5U2Hk0go83MdKzD_MIiMscwbcFsLMgRw2IU_vQF4,2213
 pixeltable/utils/filecache.py,sha256=UoNONG2VaAc2IBB0e3sQdsvyOPOes2XSDc5_CsA4qek,7839
+pixeltable/utils/formatter.py,sha256=2nAEXehP4FZQq2qzQcEJy97seRYubTuLBSrL_unRFLo,9239
 pixeltable/utils/help.py,sha256=cCnxJ4VP9MJ57iDqExmnDcM-JG3a1lw_q7g-D7bpSVI,252
 pixeltable/utils/http_server.py,sha256=WQ5ILMzlz4TlwI9j5YqAPgEZyhrN1GytMNDbLD9occk,2422
 pixeltable/utils/media_store.py,sha256=x71wnJDZDHcdd13VCfL4AkHQ6IJB41gNA-zBvXJwFos,3116
@@ -125,7 +126,7 @@ pixeltable/utils/pytorch.py,sha256=BR4tgfUWw-2rwWTOgzXj5qdMBpe1Arpp5SK4ax6jjpk,3
 pixeltable/utils/s3.py,sha256=rkanuhk9DWvSfmbOLQW1j1Iov4sl2KhxGGKN-AJ8LSE,432
 pixeltable/utils/sql.py,sha256=5n5_OmXAGtqFdL6z5XvgnU-vlx6Ba6f1WJrO1ZwUle8,765
 pixeltable/utils/transactional_directory.py,sha256=UGzCrGtLR3hEEf8sYGuWBzLVFAEQml3vdIavigWeTBM,1349
-pixeltable-0.2.10.dist-info/LICENSE,sha256=0UNMmwuqWPC0xDY1NWMm4uNJ2_MyA1pnTNRgQTvuBiQ,746
-pixeltable-0.2.10.dist-info/METADATA,sha256=mFo55wHTOiQCgUW30Lwk5aQzYglsO1Szcnq4IdSkjqU,9807
-pixeltable-0.2.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pixeltable-0.2.10.dist-info/RECORD,,
+pixeltable-0.2.11.dist-info/LICENSE,sha256=0UNMmwuqWPC0xDY1NWMm4uNJ2_MyA1pnTNRgQTvuBiQ,746
+pixeltable-0.2.11.dist-info/METADATA,sha256=c4rIZLuAKseDSgl84ndgoMupaq9XUThLxwFmaBeyjtA,9815
+pixeltable-0.2.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pixeltable-0.2.11.dist-info/RECORD,,