pixeltable 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

pixeltable/catalog/dir.py

@@ -18,16 +18,29 @@ class Dir(SchemaObject):
     def __init__(self, id: UUID, parent_id: UUID, name: str):
         super().__init__(id, name, parent_id)
 
+    @classmethod
+    def _create(cls, parent_id: UUID, name: str) -> Dir:
+        session = Env.get().session
+        assert session is not None
+        dir_md = schema.DirMd(name=name, user=None, additional_md={})
+        dir_record = schema.Dir(parent_id=parent_id, md=dataclasses.asdict(dir_md))
+        session.add(dir_record)
+        session.flush()
+        assert dir_record.id is not None
+        assert isinstance(dir_record.id, UUID)
+        dir = cls(dir_record.id, parent_id, name)
+        return dir
+
     @classmethod
     def _display_name(cls) -> str:
         return 'directory'
 
-    @property
-    def _has_dependents(self) -> bool:
-        """Returns True if this directory has any children."""
-        from pixeltable.catalog import Catalog, Path
-
-        return len(Catalog.get().paths.get_children(Path(self._path), child_type=None, recursive=False)) > 0
+    def _path(self) -> str:
+        """Returns the path to this schema object."""
+        if self._dir_id is None:
+            # we're the root dir
+            return ''
+        return super()._path()
 
     def _move(self, new_name: str, new_dir_id: UUID) -> None:
         super()._move(new_name, new_dir_id)

pixeltable/catalog/insertable_table.py

@@ -4,18 +4,16 @@ import logging
 from typing import Any, Iterable, Literal, Optional, overload
 from uuid import UUID
 
-import sqlalchemy.orm as orm
-
 import pixeltable as pxt
 import pixeltable.type_system as ts
 from pixeltable import exceptions as excs
 from pixeltable.env import Env
 from pixeltable.utils.filecache import FileCache
 
-from .catalog import Catalog
 from .globals import MediaValidation, UpdateStatus
 from .table import Table
 from .table_version import TableVersion
+from .table_version_handle import TableVersionHandle
 from .table_version_path import TableVersionPath
 
 _logger = logging.getLogger('pixeltable')
@@ -24,15 +22,14 @@ _logger = logging.getLogger('pixeltable')
 class InsertableTable(Table):
     """A `Table` that allows inserting and deleting rows."""
 
-    def __init__(self, dir_id: UUID, tbl_version: TableVersion):
+    def __init__(self, dir_id: UUID, tbl_version: TableVersionHandle):
         tbl_version_path = TableVersionPath(tbl_version)
-        super().__init__(tbl_version.id, dir_id, tbl_version.name, tbl_version_path)
+        super().__init__(tbl_version.id, dir_id, tbl_version.get().name, tbl_version_path)
 
     @classmethod
     def _display_name(cls) -> str:
         return 'table'
 
-    # MODULE-LOCAL, NOT PUBLIC
     @classmethod
     def _create(
         cls,
@@ -56,33 +53,29 @@ class InsertableTable(Table):
                 raise excs.Error(f'Primary key column {pk_col} cannot be nullable')
             col.is_pk = True
 
-        with orm.Session(Env.get().engine, future=True) as session:
-            _, tbl_version = TableVersion.create(
-                session,
-                dir_id,
-                name,
-                columns,
-                num_retained_versions=num_retained_versions,
-                comment=comment,
-                media_validation=media_validation,
-            )
-            tbl = cls(dir_id, tbl_version)
-            # TODO We need to commit before doing the insertion, in order to avoid a primary key (version) collision
-            #   when the table metadata gets updated. Once we have a notion of user-defined transactions in
-            #   Pixeltable, we can wrap the create/insert in a transaction to avoid this.
-            session.commit()
-            if df is not None:
-                # A DataFrame was provided, so insert its contents into the table
-                # (using the same DB session as the table creation)
-                tbl_version.insert(None, df, conn=session.connection(), fail_on_exception=True)
-            session.commit()
-            cat = Catalog.get()
-            cat.tbl_dependents[tbl._id] = []
-            cat.tbls[tbl._id] = tbl
-
-            _logger.info(f'Created table `{name}`, id={tbl_version.id}')
-            Env.get().console_logger.info(f'Created table `{name}`.')
-            return tbl
+        _, tbl_version = TableVersion.create(
+            dir_id,
+            name,
+            columns,
+            num_retained_versions=num_retained_versions,
+            comment=comment,
+            media_validation=media_validation,
+        )
+        tbl = cls(dir_id, TableVersionHandle.create(tbl_version))
+        # TODO We need to commit before doing the insertion, in order to avoid a primary key (version) collision
+        #   when the table metadata gets updated. Once we have a notion of user-defined transactions in
+        #   Pixeltable, we can wrap the create/insert in a transaction to avoid this.
+        session = Env.get().session
+        session.commit()
+        if df is not None:
+            # A DataFrame was provided, so insert its contents into the table
+            # (using the same DB session as the table creation)
+            tbl_version.insert(None, df, fail_on_exception=True)
+        session.commit()
+
+        _logger.info(f'Created table `{name}`, id={tbl_version.id}')
+        Env.get().console_logger.info(f'Created table `{name}`.')
+        return tbl
 
     def get_metadata(self) -> dict[str, Any]:
         md = super().get_metadata()
@@ -131,7 +124,10 @@ class InsertableTable(Table):
             if not isinstance(row, dict):
                 raise excs.Error('rows must be a list of dictionaries')
         self._validate_input_rows(rows)
-        status = self._tbl_version.insert(rows, None, print_stats=print_stats, fail_on_exception=fail_on_exception)
+        with Env.get().begin_xact():
+            status = self._tbl_version.get().insert(
+                rows, None, print_stats=print_stats, fail_on_exception=fail_on_exception
+            )
 
         if status.num_excs == 0:
             cols_with_excs_str = ''
@@ -152,8 +148,8 @@ class InsertableTable(Table):
     def _validate_input_rows(self, rows: list[dict[str, Any]]) -> None:
         """Verify that the input rows match the table schema"""
         valid_col_names = set(self._schema.keys())
-        reqd_col_names = set(self._tbl_version_path.tbl_version.get_required_col_names())
-        computed_col_names = set(self._tbl_version_path.tbl_version.get_computed_col_names())
+        reqd_col_names = set(self._tbl_version_path.tbl_version.get().get_required_col_names())
+        computed_col_names = set(self._tbl_version_path.tbl_version.get().get_computed_col_names())
         for row in rows:
             assert isinstance(row, dict)
             col_names = set(row.keys())
@@ -191,4 +187,5 @@ class InsertableTable(Table):
 
             >>> tbl.delete(tbl.a > 5)
         """
-        return self._tbl_version.delete(where=where)
+        with Env.get().begin_xact():
+            return self._tbl_version.get().delete(where=where)

pixeltable/catalog/named_function.py

@@ -27,10 +27,6 @@ class NamedFunction(SchemaObject):
     def _display_name(cls) -> str:
         return 'function'
 
-    @property
-    def _has_dependents(self) -> bool:
-        return False
-
     def _move(self, new_name: str, new_dir_id: UUID) -> None:
         super()._move(new_name, new_dir_id)
         with Env.get().engine.begin() as conn:

pixeltable/catalog/schema_object.py

@@ -2,6 +2,8 @@ from abc import abstractmethod
 from typing import TYPE_CHECKING, Any, Optional
 from uuid import UUID
 
+import pixeltable.env as env
+
 if TYPE_CHECKING:
     from pixeltable import catalog
 
@@ -12,53 +14,42 @@ class SchemaObject:
     Each object has an id, a name and a parent directory.
     """
 
+    _id: UUID
+    _name: str
+    _dir_id: Optional[UUID]
+
     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)
-        self.__id = obj_id
-        self.__name = name
-        self.__dir_id = dir_id
-
-    @property
-    def _id(self) -> UUID:
-        return self.__id
-
-    @property
-    def _name(self) -> str:
-        return self.__name
+        self._id = obj_id
+        self._name = name
+        self._dir_id = dir_id
 
-    @property
-    def _dir_id(self) -> Optional[UUID]:
-        return self.__dir_id
-
-    @property
     def _parent(self) -> Optional['catalog.Dir']:
         """Returns the parent directory of this schema object."""
-        from pixeltable import catalog
+        from .catalog import Catalog
 
-        if self._dir_id is None:
-            return None
-        dir = catalog.Catalog.get().paths.get_schema_obj(self._dir_id)
-        assert isinstance(dir, catalog.Dir)
-        return dir
+        with env.Env.get().begin_xact():
+            if self._dir_id is None:
+                return None
+            return Catalog.get().get_dir(self._dir_id)
 
-    @property
     def _path(self) -> str:
         """Returns the path to this schema object."""
-        parent = self._parent
-        if parent is None or parent._parent is None:
-            # Either this is the root directory, with empty path, or its parent is the
-            # root directory. Either way, we return just the name.
-            return self._name
-        else:
-            return f'{parent._path}.{self._name}'
+        with env.Env.get().begin_xact():
+            from .catalog import Catalog
+
+            cat = Catalog.get()
+            dir_path = cat.get_dir_path(self._dir_id)
+            if dir_path == '':
+                # Either this is the root directory, with empty path, or its parent is the
+                # root directory. Either way, we return just the name.
+                return self._name
+            else:
+                return f'{dir_path}.{self._name}'
 
     def get_metadata(self) -> dict[str, Any]:
         """Returns metadata associated with this schema object."""
-        return {
-            'name': self._name,
-            'path': self._path,
-            'parent': self._parent._path if self._parent is not None else None,
-        }
+        return {'name': self._name, 'path': self._path()}
 
     @classmethod
     @abstractmethod
@@ -68,12 +59,7 @@ class SchemaObject:
         """
         pass
 
-    @property
-    @abstractmethod
-    def _has_dependents(self) -> bool:
-        """Returns True if this object has dependents (e.g., children, views)"""
-
     def _move(self, new_name: str, new_dir_id: UUID) -> None:
         """Subclasses need to override this to make the change persistent"""
-        self.__name = new_name
-        self.__dir_id = new_dir_id
+        self._name = new_name
+        self._dir_id = new_dir_id