pixeltable 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = '0.4.4'
-__version_tuple__ = (0, 4, 4)
+__version__ = '0.0.0'
+__version_tuple__ = (0, 0, 0)

pixeltable/catalog/catalog.py

@@ -165,7 +165,7 @@ class Catalog:
     # - mutable version of a table: version == None (even though TableVersion.version is set correctly)
     # - snapshot versions: records the version of the snapshot
     _tbl_versions: dict[tuple[UUID, Optional[int]], TableVersion]
-    _tbls: dict[UUID, Table]
+    _tbls: dict[tuple[UUID, Optional[int]], Table]
     _in_write_xact: bool  # True if we're in a write transaction
     _x_locked_tbl_ids: set[UUID]  # non-empty for write transactions
     _modified_tvs: set[TableVersionHandle]  # TableVersion instances modified in the current transaction
@@ -698,6 +698,7 @@ class Catalog:
 
     def get_dir_path(self, dir_id: UUID) -> Path:
         """Return path for directory with given id"""
+        assert isinstance(dir_id, UUID)
         conn = Env.get().conn
         names: list[str] = []
         while True:
@@ -708,7 +709,7 @@ class Catalog:
                 break
             names.insert(0, dir.md['name'])
             dir_id = dir.parent_id
-        return Path('.'.join(names), empty_is_valid=True, allow_system_paths=True)
+        return Path.parse('.'.join(names), allow_empty_path=True, allow_system_path=True)
 
     @dataclasses.dataclass
     class DirEntry:
@@ -825,7 +826,9 @@ class Catalog:
         add_dir_obj = Dir(add_dir.id, add_dir.parent_id, add_dir.md['name']) if add_dir is not None else None
         return add_obj, add_dir_obj, drop_obj
 
-    def _get_dir_entry(self, dir_id: UUID, name: str, lock_entry: bool = False) -> Optional[SchemaObject]:
+    def _get_dir_entry(
+        self, dir_id: UUID, name: str, version: Optional[int] = None, lock_entry: bool = False
+    ) -> Optional[SchemaObject]:
         user = Env.get().user
         conn = Env.get().conn
 
@@ -854,9 +857,7 @@ class Catalog:
         )
         tbl_id = conn.execute(q).scalar_one_or_none()
         if tbl_id is not None:
-            if tbl_id not in self._tbls:
-                _ = self._load_tbl(tbl_id)
-            return self._tbls[tbl_id]
+            return self.get_table_by_id(tbl_id, version)
 
         return None
 
@@ -872,7 +873,7 @@ class Catalog:
         """Return the schema object at the given path, or None if it doesn't exist.
 
         Raises Error if
-        - the parent directory doesn't exist'
+        - the parent directory doesn't exist
         - raise_if_exists is True and the path exists
         - raise_if_not_exists is True and the path does not exist
         - expected is not None and the existing object has a different type
@@ -892,7 +893,7 @@ class Catalog:
         parent_dir = self._get_dir(parent_path, lock_dir=lock_parent)
         if parent_dir is None:
             raise excs.Error(f'Directory {parent_path!r} does not exist.')
-        obj = self._get_dir_entry(parent_dir.id, path.name, lock_entry=lock_obj)
+        obj = self._get_dir_entry(parent_dir.id, path.name, path.version, lock_entry=lock_obj)
 
         if obj is None and raise_if_not_exists:
             raise excs.Error(f'Path {path!r} does not exist.')
@@ -903,18 +904,14 @@ class Catalog:
             raise excs.Error(f'{path!r} needs to be a {expected_name} but is a {obj._display_name()}.')
         return obj
 
-    def get_table_by_id(self, tbl_id: UUID) -> Optional[Table]:
+    def get_table_by_id(self, tbl_id: UUID, version: Optional[int] = None) -> Optional[Table]:
         """Must be executed inside a transaction. Might raise PendingTableOpsError."""
-        if tbl_id in self._tbls:
-            return self._tbls[tbl_id]
-        tbl = self._load_tbl(tbl_id)
-        # # if this is a mutable table, we also need to have its mutable views loaded, in order to track column
-        # # dependencies
-        # tbl_version = tbl._tbl_version.get()
-        # if tbl_version.is_mutable:
-        #     for v in tbl_version.mutable_views:
-        #         _ = self.get_table_by_id(v.id)
-        return tbl
+        if (tbl_id, version) not in self._tbls:
+            if version is None:
+                self._load_tbl(tbl_id)
+            else:
+                self._load_tbl_at_version(tbl_id, version)
+        return self._tbls.get((tbl_id, version))
 
     @retry_loop(for_write=True)
     def create_table(
@@ -946,7 +943,7 @@ class Catalog:
             comment=comment,
             media_validation=media_validation,
         )
-        self._tbls[tbl._id] = tbl
+        self._tbls[tbl._id, None] = tbl
         return tbl
 
     def create_view(
@@ -1045,12 +1042,12 @@ class Catalog:
             )
 
         # Ensure that the system directory exists.
-        self._create_dir(Path('_system', allow_system_paths=True), if_exists=IfExistsParam.IGNORE, parents=False)
+        self._create_dir(Path.parse('_system', allow_system_path=True), if_exists=IfExistsParam.IGNORE, parents=False)
 
         # Now check to see if this table already exists in the catalog.
         existing = self.get_table_by_id(tbl_id)
         if existing is not None:
-            existing_path = Path(existing._path(), allow_system_paths=True)
+            existing_path = Path.parse(existing._path(), allow_system_path=True)
             if existing_path != path:
                 # It does exist, under a different path from the specified one.
                 if not existing_path.is_system_path:
@@ -1073,12 +1070,12 @@ class Catalog:
             replica_path: Path
             if replica is None:
                 # We've never seen this table before. Create a new anonymous system table for it.
-                replica_path = Path(f'_system.replica_{ancestor_id.hex}', allow_system_paths=True)
+                replica_path = Path.parse(f'_system.replica_{ancestor_id.hex}', allow_system_path=True)
             else:
                 # The table already exists in the catalog. The existing path might be a system path (if the table
                 # was created as an anonymous base table of some other table), or it might not (if it's a snapshot
                 # that was directly replicated by the user at some point). In either case, use the existing path.
-                replica_path = Path(replica._path(), allow_system_paths=True)
+                replica_path = Path.parse(replica._path(), allow_system_path=True)
 
             # Store the metadata; it could be a new version (in which case a new record will be created), or a known
             # version (in which case the newly received metadata will be validated as identical).
@@ -1138,7 +1135,7 @@ class Catalog:
         q = (
             sql.select(schema.TableVersion.md)
             .where(schema.TableVersion.tbl_id == tbl_id)
-            .where(sql.text(f"({schema.TableVersion.__table__}.md->>'version')::int = {md.version_md.version}"))
+            .where(schema.TableVersion.md['version'].cast(sql.Integer) == md.version_md.version)
         )
         existing_version_md_row = conn.execute(q).one_or_none()
         if existing_version_md_row is None:
@@ -1157,10 +1154,7 @@ class Catalog:
             sql.select(schema.TableSchemaVersion.md)
             .where(schema.TableSchemaVersion.tbl_id == tbl_id)
             .where(
-                sql.text(
-                    f"({schema.TableSchemaVersion.__table__}.md->>'schema_version')::int = "
-                    f'{md.schema_version_md.schema_version}'
-                )
+                schema.TableSchemaVersion.md['schema_version'].cast(sql.Integer) == md.schema_version_md.schema_version
             )
         )
         existing_schema_version_md_row = conn.execute(q).one_or_none()
@@ -1274,8 +1268,10 @@ class Catalog:
             tv.drop()
 
         self.delete_tbl_md(tbl._id)
-        assert tbl._id in self._tbls
-        del self._tbls[tbl._id]
+        assert (tbl._id, None) in self._tbls
+        versions = [k[1] for k in self._tbls if k[0] == tbl._id]
+        for version in versions:
+            del self._tbls[tbl._id, version]
         _logger.info(f'Dropped table `{tbl._path()}`.')
 
     @retry_loop(for_write=True)
@@ -1363,7 +1359,7 @@ class Catalog:
         tbl_count = conn.execute(q).scalar()
         if tbl_count == 0:
             raise excs.Error(self._dropped_tbl_error_msg(tbl_id))
-        q = sql.select(schema.Table.id).where(sql.text(f"md->'view_md'->'base_versions'->0->>0 = {tbl_id.hex!r}"))
+        q = sql.select(schema.Table.id).where(schema.Table.md['view_md']['base_versions'][0][0].astext == tbl_id.hex)
         if for_update:
             q = q.with_for_update()
         result = [r[0] for r in conn.execute(q).all()]
@@ -1462,7 +1458,7 @@ class Catalog:
             row = conn.execute(q).one_or_none()
             return schema.Dir(**row._mapping) if row is not None else None
 
-    def _load_tbl(self, tbl_id: UUID) -> Optional[Table]:
+    def _load_tbl(self, tbl_id: UUID) -> None:
         """Loads metadata for the table with the given id and caches it."""
         _logger.info(f'Loading table {tbl_id}')
         from .insertable_table import InsertableTable
@@ -1480,12 +1476,8 @@ class Catalog:
             sql.select(schema.Table, schema.TableSchemaVersion)
             .join(schema.TableSchemaVersion)
             .where(schema.Table.id == schema.TableSchemaVersion.tbl_id)
-            # Table.md['current_schema_version'] == TableSchemaVersion.schema_version
             .where(
-                sql.text(
-                    f"({schema.Table.__table__}.md->>'current_schema_version')::int = "
-                    f'{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}'
-                )
+                schema.Table.md['current_schema_version'].cast(sql.Integer) == schema.TableSchemaVersion.schema_version
             )
             .where(schema.Table.id == tbl_id)
         )
@@ -1501,8 +1493,8 @@ class Catalog:
             if (tbl_id, None) not in self._tbl_versions:
                 _ = self._load_tbl_version(tbl_id, None)
             tbl = InsertableTable(tbl_record.dir_id, TableVersionHandle(tbl_id, None))
-            self._tbls[tbl_id] = tbl
-            return tbl
+            self._tbls[tbl_id, None] = tbl
+            return
 
         # this is a view; determine the sequence of TableVersions to load
         tbl_version_path: list[tuple[UUID, Optional[int]]] = []
@@ -1526,8 +1518,68 @@ class Catalog:
             view_path = TableVersionPath(TableVersionHandle(id, effective_version), base=base_path)
             base_path = view_path
         view = View(tbl_id, tbl_record.dir_id, tbl_md.name, view_path, snapshot_only=tbl_md.is_pure_snapshot)
-        self._tbls[tbl_id] = view
-        return view
+        self._tbls[tbl_id, None] = view
+
+    def _load_tbl_at_version(self, tbl_id: UUID, version: int) -> None:
+        from .view import View
+
+        # Load the specified TableMd and TableVersionMd records from the db.
+        conn = Env.get().conn
+        q: sql.Executable = (
+            sql.select(schema.Table, schema.TableVersion)
+            .join(schema.TableVersion)
+            .where(schema.Table.id == tbl_id)
+            .where(schema.Table.id == schema.TableVersion.tbl_id)
+            .where(schema.TableVersion.version == version)
+        )
+        row = conn.execute(q).one_or_none()
+        if row is None:
+            return None
+        tbl_record, version_record = _unpack_row(row, [schema.Table, schema.TableVersion])
+        tbl_md = schema.md_from_dict(schema.TableMd, tbl_record.md)
+        version_md = schema.md_from_dict(schema.TableVersionMd, version_record.md)
+
+        # Reconstruct the TableVersionPath for the specified TableVersion. We do this by examining the created_at
+        # timestamps of this table and all its ancestors.
+        # TODO: Store the relevant TableVersionPaths in the database, so that we don't need to rely on timestamps
+        #     (which might be nondeterministic in the future).
+
+        # Build the list of ancestor versions, starting with the given table and traversing back to the base table.
+        # For each proper ancestor, we use the version whose created_at timestamp equals or most nearly precedes the
+        # given TableVersion's created_at timestamp.
+        ancestors: list[tuple[UUID, Optional[int]]] = [(tbl_id, version)]
+        if tbl_md.view_md is not None:
+            for ancestor_id, _ in tbl_md.view_md.base_versions:
+                q = (
+                    sql.select(schema.TableVersion)
+                    .where(schema.TableVersion.tbl_id == ancestor_id)
+                    .where(schema.TableVersion.md['created_at'].cast(sql.Float) <= version_md.created_at)
+                    .order_by(schema.TableVersion.md['created_at'].cast(sql.Float).desc())
+                    .limit(1)
+                )
+                row = conn.execute(q).one_or_none()
+                if row is None:
+                    # This can happen if an ancestor version is garbage collected; it can also happen in
+                    # rare circumstances involving table versions created specifically with Pixeltable 0.4.3.
+                    _logger.info(f'Ancestor {ancestor_id} not found for table {tbl_id}:{version}')
+                    raise excs.Error('The specified table version is no longer valid and cannot be retrieved.')
+                ancestor_version_record = _unpack_row(row, [schema.TableVersion])[0]
+                ancestor_version_md = schema.md_from_dict(schema.TableVersionMd, ancestor_version_record.md)
+                assert ancestor_version_md.created_at <= version_md.created_at
+                ancestors.append((UUID(ancestor_id), ancestor_version_md.version))
+
+        # Force any ancestors to be loaded (base table first).
+        for anc_id, anc_version in ancestors[::-1]:
+            if (anc_id, anc_version) not in self._tbl_versions:
+                _ = self._load_tbl_version(anc_id, anc_version)
+
+        # Now reconstruct the relevant TableVersionPath instance from the ancestor versions.
+        tvp: Optional[TableVersionPath] = None
+        for anc_id, anc_version in ancestors[::-1]:
+            tvp = TableVersionPath(TableVersionHandle(anc_id, anc_version), base=tvp)
+
+        view = View(tbl_id, tbl_record.dir_id, tbl_md.name, tvp, snapshot_only=True)
+        self._tbls[tbl_id, version] = view
 
     @retry_loop(for_write=False)
     def collect_tbl_history(self, tbl_id: UUID, n: Optional[int]) -> list[schema.FullTableMd]:
@@ -1547,8 +1599,7 @@ class Catalog:
             .select_from(schema.TableVersion)
             .join(
                 schema.TableSchemaVersion,
-                sql.cast(schema.TableVersion.md['schema_version'], sql.Integer)
-                == schema.TableSchemaVersion.schema_version,
+                schema.TableVersion.md['schema_version'].cast(sql.Integer) == schema.TableSchemaVersion.schema_version,
             )
             .where(schema.TableVersion.tbl_id == tbl_id)
             .where(schema.TableSchemaVersion.tbl_id == tbl_id)
@@ -1590,13 +1641,9 @@ class Catalog:
             # JOIN TableVersion tv ON (tv.tbl_id = tbl_id AND tv.version = effective_version)
             # JOIN TableSchemaVersion tsv ON (tsv.tbl_id = tbl_id AND tv.md.schema_version = tsv.schema_version)
             # WHERE t.id = tbl_id
-            q = q.where(sql.text(f"({schema.TableVersion.__table__}.md->>'version')::int = {effective_version}")).where(
-                sql.text(
-                    (
-                        f"({schema.TableVersion.__table__}.md->>'schema_version')::int = "
-                        f'{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}'
-                    )
-                )
+            q = q.where(
+                schema.TableVersion.md['version'].cast(sql.Integer) == effective_version,
+                schema.TableVersion.md['schema_version'].cast(sql.Integer) == schema.TableSchemaVersion.schema_version,
             )
         else:
             # we are loading the current version
@@ -1606,17 +1653,8 @@ class Catalog:
             # JOIN TableSchemaVersion tsv ON (tsv.tbl_id = tbl_id AND t.current_schema_version = tsv.schema_version)
             # WHERE t.id = tbl_id
             q = q.where(
-                sql.text(
-                    f"({schema.Table.__table__}.md->>'current_version')::int = "
-                    f'{schema.TableVersion.__table__}.{schema.TableVersion.version.name}'
-                )
-            ).where(
-                sql.text(
-                    (
-                        f"({schema.Table.__table__}.md->>'current_schema_version')::int = "
-                        f'{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}'
-                    )
-                )
+                schema.Table.md['current_version'].cast(sql.Integer) == schema.TableVersion.version,
+                schema.Table.md['current_schema_version'].cast(sql.Integer) == schema.TableSchemaVersion.schema_version,
             )
 
         row = conn.execute(q).one_or_none()
@@ -1719,9 +1757,7 @@ class Catalog:
         stmt = (
             sql.update(schema.TableVersion)
             .where(schema.TableVersion.tbl_id == tbl_id, schema.TableVersion.version == version)
-            .values(
-                md=schema.TableVersion.md.op('||')({'additional_md': {'update_status': dataclasses.asdict(status)}})
-            )
+            .values(md=schema.TableVersion.md.op('||')({'update_status': dataclasses.asdict(status)}))
         )
 
         res = conn.execute(stmt)
@@ -1798,11 +1834,10 @@ class Catalog:
         # This is presumably a source of bugs, because it ignores schema version changes (eg, column renames).
         # TODO: retarget the value_expr_dict when instantiating Columns for a particular TV instance.
         if effective_version is None and not tbl_md.is_replica:
-            q = sql.select(schema.Table.id).where(
-                sql.text(
-                    f"md->'view_md'->'base_versions'->0->>0 = {tbl_id.hex!r} "
-                    "AND md->'view_md'->'base_versions'->0->>1 IS NULL"
-                )
+            q = (
+                sql.select(schema.Table.id)
+                .where(schema.Table.md['view_md']['base_versions'][0][0].astext == tbl_id.hex)
+                .where(schema.Table.md['view_md']['base_versions'][0][1].astext == None)
             )
             mutable_view_ids = [r[0] for r in conn.execute(q).all()]
 
@@ -1839,9 +1874,9 @@ class Catalog:
                 version_md,
                 effective_version,
                 schema_version_md,
+                mutable_views,
                 base_path=base_path,
                 base=base,
-                mutable_views=mutable_views,
             )
 
         # register the instance before init()

pixeltable/catalog/path.py

@@ -1,20 +1,57 @@
 from __future__ import annotations
 
 import logging
-from typing import Iterator
+from typing import Optional
 
 from pixeltable import exceptions as excs
 
-from .globals import is_valid_path
+from .globals import is_valid_identifier
 
 _logger = logging.getLogger('pixeltable')
 
 
 class Path:
-    def __init__(self, path: str, empty_is_valid: bool = False, allow_system_paths: bool = False):
-        if not is_valid_path(path, empty_is_valid, allow_system_paths):
-            raise excs.Error(f"Invalid path format: '{path}'")
-        self.components = path.split('.')
+    components: list[str]
+    version: Optional[int]
+
+    def __init__(self, components: list[str], version: Optional[int] = None) -> None:
+        assert len(components) > 0
+        self.components = components
+        self.version = version
+
+    @classmethod
+    def parse(
+        cls,
+        path: str,
+        allow_empty_path: bool = False,
+        allow_system_path: bool = False,
+        allow_versioned_path: bool = False,
+    ) -> Path:
+        components: list[str]
+        version: Optional[int]
+        if ':' in path:
+            parts = path.split(':')
+            if len(parts) != 2:
+                raise excs.Error(f'Invalid path: {path}')
+            try:
+                components = parts[0].split('.')
+                version = int(parts[1])
+            except ValueError:
+                raise excs.Error(f'Invalid path: {path}') from None
+        else:
+            components = path.split('.')
+            version = None
+
+        if components == [''] and not allow_empty_path:
+            raise excs.Error(f'Invalid path: {path}')
+
+        if components != [''] and not all(is_valid_identifier(c, allow_system_path) for c in components):
+            raise excs.Error(f'Invalid path: {path}')
+
+        if version is not None and not allow_versioned_path:
+            raise excs.Error(f'Versioned path not allowed here: {path}')
+
+        return Path(components, version)
 
     @property
     def len(self) -> int:
@@ -22,7 +59,6 @@ class Path:
 
     @property
     def name(self) -> str:
-        assert len(self.components) > 0
         return self.components[-1]
 
     @property
@@ -36,18 +72,15 @@ class Path:
     @property
     def parent(self) -> Path:
         if len(self.components) == 1:
-            if self.is_root:
-                return self
-            else:
-                return Path('', empty_is_valid=True, allow_system_paths=True)
+            return ROOT_PATH  # Includes the case of the root path, which is its own parent.
         else:
-            return Path('.'.join(self.components[:-1]), allow_system_paths=True)
+            return Path(self.components[:-1])
 
     def append(self, name: str) -> Path:
         if self.is_root:
-            return Path(name, allow_system_paths=True)
+            return Path([name])
         else:
-            return Path(f'{self}.{name}', allow_system_paths=True)
+            return Path([*self.components, name])
 
     def is_ancestor(self, other: Path, is_parent: bool = False) -> bool:
         """
@@ -60,22 +93,25 @@ class Path:
         is_prefix = self.components == other.components[: self.len]
         return is_prefix and (self.len == (other.len - 1) or not is_parent)
 
-    def ancestors(self) -> Iterator[Path]:
+    def ancestors(self) -> list[Path]:
         """
-        Return all ancestors of this path in top-down order including root.
+        Return all proper ancestors of this path in top-down order including root.
         If this path is for the root directory, which has no parent, then None is returned.
         """
         if self.is_root:
-            return
+            return []
         else:
-            for i in range(0, len(self.components)):
-                yield Path('.'.join(self.components[0:i]), empty_is_valid=True)
+            return [Path(self.components[:i]) if i > 0 else ROOT_PATH for i in range(len(self.components))]
 
     def __repr__(self) -> str:
         return repr(str(self))
 
     def __str__(self) -> str:
-        return '.'.join(self.components)
+        base = '.'.join(self.components)
+        if self.version is not None:
+            return f'{base}:{self.version}'
+        else:
+            return base
 
     def __eq__(self, other: object) -> bool:
         return isinstance(other, Path) and str(self) == str(other)
@@ -85,3 +121,6 @@ class Path:
 
     def __lt__(self, other: Path) -> bool:
         return str(self) < str(other)
+
+
+ROOT_PATH = Path([''])

pixeltable/catalog/schema_object.py

@@ -18,6 +18,7 @@ class SchemaObject:
 
     def __init__(self, obj_id: UUID, name: str, dir_id: Optional[UUID]):
         # make these private so they don't collide with column names (id and name are fairly common)
+        assert dir_id is None or isinstance(dir_id, UUID), type(dir_id)
         self._id = obj_id
         self._name = name
         self._dir_id = dir_id

pixeltable/catalog/table.py

@@ -89,6 +89,8 @@ class Table(SchemaObject):
 
                 ```python
                 {
+                    'name': 'my_table',
+                    'path': 'my_dir.my_subdir.my_table',
                     'base': None,  # If this is a view or snapshot, will contain the name of its base table
                     'schema': {
                         'col1': StringType(),
@@ -96,6 +98,7 @@ class Table(SchemaObject):
                     },
                     'is_replica': False,
                     'version': 22,
+                    'version_created': datetime.datetime(...),
                     'schema_version': 1,
                     'comment': '',
                     'num_retained_versions': 10,
@@ -112,6 +115,9 @@ class Table(SchemaObject):
         md['schema'] = self._get_schema()
         md['is_replica'] = self._tbl_version_path.is_replica()
         md['version'] = self._get_version()
+        md['version_created'] = datetime.datetime.fromtimestamp(
+            self._tbl_version_path.tbl_version.get().created_at, tz=datetime.timezone.utc
+        )
         md['schema_version'] = self._tbl_version_path.schema_version()
         md['comment'] = self._get_comment()
         md['num_retained_versions'] = self._get_num_retained_versions()

pixeltable/catalog/table_version.py

@@ -773,6 +773,7 @@ class TableVersion:
         cols_to_add = list(cols)
         row_count = self.store_tbl.count()
         for col in cols_to_add:
+            assert col.tbl is self
             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'
@@ -1325,7 +1326,7 @@ class TableVersion:
             )
 
         # delete newly-added data
-        MediaStore.delete(self.id, version=self.version)
+        MediaStore.delete(self.id, tbl_version=self.version)
         conn.execute(sql.delete(self.store_tbl.sa_tbl).where(self.store_tbl.sa_tbl.c.v_min == self.version))
 
         # revert new deletions

pixeltable/catalog/view.py

@@ -255,10 +255,20 @@ class View(Table):
             base=cls._get_snapshot_path(tbl_version_path.base) if tbl_version_path.base is not None else None,
         )
 
+    def _is_anonymous_snapshot(self) -> bool:
+        """
+        Returns True if this is an unnamed snapshot (i.e., a snapshot that is not a separate schema object).
+        """
+        return self._snapshot_only and self._id == self._tbl_version_path.tbl_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()
+        if self._is_anonymous_snapshot():
+            # Update name and path with version qualifiers.
+            md['name'] = f'{self._name}:{self._tbl_version_path.version()}'
+            md['path'] = f'{self._path()}:{self._tbl_version_path.version()}'
         base_tbl = self._get_base_table()
         if base_tbl is None:
             md['base'] = None
@@ -284,21 +294,22 @@ class View(Table):
         raise excs.Error(f'{self._display_str()}: Cannot delete from a {self._display_name()}.')
 
     def _get_base_table(self) -> Optional['Table']:
-        if self._tbl_version_path.base is None and not self._snapshot_only:
-            return None  # this can happen for a replica of a base table
-        # if this is a pure snapshot, our tbl_version_path only reflects the base (there is no TableVersion instance
-        # for the snapshot itself)
-        from pixeltable.catalog import Catalog
-
-        base_id = self._tbl_version_path.tbl_id if self._snapshot_only else self._tbl_version_path.base.tbl_id
-        with Catalog.get().begin_xact(tbl_id=base_id, for_write=False):
+        if self._tbl_version_path.tbl_id != self._id:
+            # _tbl_version_path represents a different schema object from this one. This can only happen if this is a
+            # named pure snapshot.
+            base_id = self._tbl_version_path.tbl_id
+        elif self._tbl_version_path.base is None:
+            return None
+        else:
+            base_id = self._tbl_version_path.base.tbl_id
+        with catalog.Catalog.get().begin_xact(tbl_id=base_id, for_write=False):
             return catalog.Catalog.get().get_table_by_id(base_id)
 
     @property
     def _effective_base_versions(self) -> list[Optional[int]]:
         effective_versions = [tv.effective_version for tv in self._tbl_version_path.get_tbl_versions()]
-        if self._snapshot_only:
-            return effective_versions
+        if self._snapshot_only and not self._is_anonymous_snapshot():
+            return effective_versions  # Named pure snapshot
         else:
             return effective_versions[1:]
 

pixeltable/config.py

@@ -8,7 +8,7 @@ from typing import Any, ClassVar, Optional, TypeVar
 
 import toml
 
-from pixeltable import exceptions as excs
+from pixeltable import env, exceptions as excs
 
 _logger = logging.getLogger('pixeltable')
 
@@ -82,7 +82,11 @@ class Config:
         return cls.__instance
 
     @classmethod
-    def init(cls, config_overrides: dict[str, Any]) -> None:
+    def init(cls, config_overrides: dict[str, Any], reinit: bool = False) -> None:
+        if reinit:
+            cls.__instance = None
+            for cl in env._registered_clients.values():
+                cl.client_obj = None
         if cls.__instance is None:
             cls.__instance = cls(config_overrides)
         elif len(config_overrides) > 0:
@@ -102,7 +106,7 @@ class Config:
         env_var = f'{section.upper()}_{key.upper()}'
         if override_var in self.__config_overrides:
             return self.__config_overrides[override_var]
-        if env_var in os.environ:
+        if env_var in os.environ and len(os.environ[env_var]) > 0:
             return os.environ[env_var]
         return default
 
@@ -157,7 +161,11 @@ KNOWN_CONFIG_OPTIONS = {
     'groq': {'api_key': 'Groq API key'},
     'label_studio': {'api_key': 'Label Studio API key', 'url': 'Label Studio server URL'},
     'mistral': {'api_key': 'Mistral API key'},
-    'openai': {'api_key': 'OpenAI API key'},
+    'openai': {
+        'api_key': 'OpenAI API key',
+        'base_url': 'OpenAI API base URL',
+        'api_version': 'API version if using Azure OpenAI',
+    },
     'replicate': {'api_token': 'Replicate API token'},
     'together': {'api_key': 'Together API key'},
     'pypi': {'api_key': 'PyPI API key (for internal use only)'},