pixeltable 0.2.15__py3-none-any.whl → 0.2.17__py3-none-any.whl

pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.2.15"
-__version_tuple__ = (0, 2, 15)
+__version__ = "0.2.17"
+__version_tuple__ = (0, 2, 17)

pixeltable/catalog/column.py

@@ -196,6 +196,9 @@ class Column:
     def __str__(self) -> str:
         return f'{self.name}: {self.col_type}'
 
+    def __repr__(self) -> str:
+        return f'Column({self.id!r}, {self.name!r}, tbl={self.tbl.name!r})'
+
     def __hash__(self) -> int:
         # TODO(aaron-siegel): This and __eq__ do not capture the table version. We need to rethink the Column
         #     abstraction (perhaps separating out the version-dependent properties into a different abstraction).

pixeltable/catalog/dir.py

@@ -18,7 +18,7 @@ class Dir(SchemaObject):
         super().__init__(id, name, parent_id)
 
     @classmethod
-    def display_name(cls) -> str:
+    def _display_name(cls) -> str:
         return 'directory'
 
     def _move(self, new_name: str, new_dir_id: UUID) -> None:

pixeltable/catalog/globals.py

@@ -1,14 +1,18 @@
-from typing import List
 import dataclasses
+import itertools
 import logging
-
+from typing import Optional
 
 _logger = logging.getLogger('pixeltable')
 
 # name of the position column in a component view
-POS_COLUMN_NAME = 'pos'
+_POS_COLUMN_NAME = 'pos'
 _ROWID_COLUMN_NAME = '_rowid'
 
+# Set of symbols that are predefined in the `InsertableTable` class (and are therefore not allowed as column names).
+# This will be populated lazily to avoid circular imports.
+_PREDEF_SYMBOLS: Optional[set[str]] = None
+
 
 @dataclasses.dataclass
 class UpdateStatus:
@@ -16,8 +20,8 @@ class UpdateStatus:
     # TODO: disambiguate what this means: # of slots computed or # of columns computed?
     num_computed_values: int = 0
     num_excs: int = 0
-    updated_cols: List[str] = dataclasses.field(default_factory=list)
-    cols_with_excs: List[str] = dataclasses.field(default_factory=list)
+    updated_cols: list[str] = dataclasses.field(default_factory=list)
+    cols_with_excs: list[str] = dataclasses.field(default_factory=list)
 
     def __iadd__(self, other: 'UpdateStatus') -> 'UpdateStatus':
         self.num_rows += other.num_rows
@@ -40,4 +44,9 @@ def is_valid_path(path: str, empty_is_valid : bool) -> bool:
     return True
 
 def is_system_column_name(name: str) -> bool:
-    return name == POS_COLUMN_NAME
+    from pixeltable.catalog import InsertableTable, View
+
+    global _PREDEF_SYMBOLS
+    if _PREDEF_SYMBOLS is None:
+        _PREDEF_SYMBOLS = set(itertools.chain(dir(InsertableTable), dir(View)))
+    return name == _POS_COLUMN_NAME or name in _PREDEF_SYMBOLS

pixeltable/catalog/insertable_table.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional, List, Any, Dict, overload, Iterable
+from typing import Any, Dict, Iterable, List, Optional, overload
 from uuid import UUID
 
 import sqlalchemy.orm as orm
 
-import pixeltable
+import pixeltable as pxt
 import pixeltable.type_system as ts
 from pixeltable import exceptions as excs
 from pixeltable.env import Env
+
 from .catalog import Catalog
 from .globals import UpdateStatus
 from .table import Table
@@ -27,13 +28,13 @@ class InsertableTable(Table):
         super().__init__(tbl_version.id, dir_id, tbl_version.name, tbl_version_path)
 
     @classmethod
-    def display_name(cls) -> str:
+    def _display_name(cls) -> str:
         return 'table'
 
     # MODULE-LOCAL, NOT PUBLIC
     @classmethod
-    def create(
-            cls, dir_id: UUID, name: str, schema: Dict[str, ts.ColumnType], primary_key: List[str],
+    def _create(
+            cls, dir_id: UUID, name: str, schema: dict[str, ts.ColumnType], df: Optional[pxt.DataFrame], primary_key: List[str],
             num_retained_versions: int, comment: str
     ) -> InsertableTable:
         columns = cls._create_columns(schema)
@@ -50,6 +51,14 @@ class InsertableTable(Table):
         with orm.Session(Env.get().engine, future=True) as session:
             _, tbl_version = TableVersion.create(session, dir_id, name, columns, num_retained_versions, comment)
             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] = []
@@ -59,6 +68,12 @@ class InsertableTable(Table):
             print(f'Created table `{name}`.')
             return tbl
 
+    def get_metadata(self) -> dict[str, Any]:
+        md = super().get_metadata()
+        md['is_view'] = False
+        md['is_snapshot'] = False
+        return md
+
     @overload
     def insert(
             self, rows: Iterable[Dict[str, Any]], /, *, print_stats: bool = False, fail_on_exception: bool = True
@@ -86,7 +101,7 @@ class InsertableTable(Table):
             if not isinstance(row, dict):
                 raise excs.Error('rows must be a list of dictionaries')
         self._validate_input_rows(rows)
-        result = self._tbl_version.insert(rows, print_stats=print_stats, fail_on_exception=fail_on_exception)
+        result = self._tbl_version.insert(rows, None, print_stats=print_stats, fail_on_exception=fail_on_exception)
 
         if result.num_excs == 0:
             cols_with_excs_str = ''
@@ -104,7 +119,7 @@ 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.column_names())
+        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())
         for row in rows:
@@ -129,7 +144,7 @@ class InsertableTable(Table):
                     msg = str(e)
                     raise excs.Error(f'Error in column {col.name}: {msg[0].lower() + msg[1:]}\nRow: {row}')
 
-    def delete(self, where: Optional['pixeltable.exprs.Expr'] = None) -> UpdateStatus:
+    def delete(self, where: Optional['pxt.exprs.Expr'] = None) -> UpdateStatus:
         """Delete rows in this table.
 
         Args:

pixeltable/catalog/named_function.py

@@ -22,7 +22,7 @@ class NamedFunction(SchemaObject):
         super().__init__(id, name, dir_id)
 
     @classmethod
-    def display_name(cls) -> str:
+    def _display_name(cls) -> str:
         return 'function'
 
     def _move(self, new_name: str, new_dir_id: UUID) -> None:

pixeltable/catalog/path_dict.py

@@ -114,20 +114,20 @@ class PathDict:
             schema_obj = self._resolve_path(path)
             if not isinstance(schema_obj, expected):
                 raise excs.Error(
-                    f'{str(path)} needs to be a {expected.display_name()} but is a {type(schema_obj).display_name()}')
+                    f'{str(path)} needs to be a {expected._display_name()} but is a {type(schema_obj)._display_name()}')
         if expected is None:
             parent_obj = self._resolve_path(path.parent)
             if not isinstance(parent_obj, Dir):
                 raise excs.Error(
-                    f'{str(path.parent)} is a {type(parent_obj).display_name()}, not a {Dir.display_name()}')
+                    f'{str(path.parent)} is a {type(parent_obj)._display_name()}, not a {Dir._display_name()}')
             if path.name in self.dir_contents[parent_obj._id]:
                 obj = self.dir_contents[parent_obj._id][path.name]
-                raise excs.Error(f"{type(obj).display_name()} '{str(path)}' already exists")
+                raise excs.Error(f"{type(obj)._display_name()} '{str(path)}' already exists")
 
     def get_children(self, parent: Path, child_type: Optional[Type[SchemaObject]], recursive: bool) -> List[Path]:
         dir = self._resolve_path(parent)
         if not isinstance(dir, Dir):
-            raise excs.Error(f'{str(parent)} is a {type(dir).display_name()}, not a directory')
+            raise excs.Error(f'{str(parent)} is a {type(dir)._display_name()}, not a directory')
         matches = [
             obj for obj in self.dir_contents[dir._id].values() if child_type is None or isinstance(obj, child_type)
         ]

pixeltable/catalog/schema_object.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Optional
 from uuid import UUID
 
 if TYPE_CHECKING:
@@ -13,20 +13,24 @@ 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)
-        self._id = obj_id
-        self._name = name
-        self._dir_id = dir_id
+        self.__id = obj_id
+        self.__name = name
+        self.__dir_id = dir_id
 
-    def _get_id(self) -> UUID:
-        return self._id
+    @property
+    def _id(self) -> UUID:
+        return self.__id
+
+    @property
+    def _name(self) -> str:
+        return self.__name
 
     @property
-    def name(self) -> str:
-        """Returns the name of this schema object."""
-        return self._name
+    def _dir_id(self) -> Optional[UUID]:
+        return self.__dir_id
 
     @property
-    def parent(self) -> Optional['catalog.Dir']:
+    def _parent(self) -> Optional['catalog.Dir']:
         """Returns the parent directory of this schema object."""
         from pixeltable import catalog
         if self._dir_id is None:
@@ -36,19 +40,27 @@ class SchemaObject:
         return dir
 
     @property
-    def path(self) -> str:
+    def _path(self) -> str:
         """Returns the path to this schema object."""
-        parent = self.parent
-        if parent is None or parent.parent is None:
+        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
+            return self._name
         else:
-            return f'{parent.path}.{self.name}'
+            return f'{parent._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,
+        }
 
     @classmethod
     @abstractmethod
-    def display_name(cls) -> str:
+    def _display_name(cls) -> str:
         """
         Return name displayed in error messages.
         """
@@ -56,5 +68,5 @@ class SchemaObject:
 
     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