pixeltable 0.2.28__tar.gz → 0.2.29__tar.gz

{pixeltable-0.2.28 → pixeltable-0.2.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.2.28
+Version: 0.2.29
 Summary: AI Data Infrastructure: Declarative, Multimodal, and Incremental
 Home-page: https://pixeltable.com/
 License: Apache-2.0
@@ -29,13 +29,14 @@ Requires-Dist: cloudpickle (>=2.2.1,<3.0.0)
 Requires-Dist: ftfy (>=6.2.0,<7.0.0)
 Requires-Dist: jinja2 (>=3.1.3,<4.0.0)
 Requires-Dist: jmespath (>=1.0.1,<2.0.0)
+Requires-Dist: jsonschema (>=4.1.0)
 Requires-Dist: lxml (>=5.0)
 Requires-Dist: more-itertools (>=10.2,<11.0)
 Requires-Dist: numpy (>=1.25,<2.0)
 Requires-Dist: pandas (>=2.0,<3.0)
 Requires-Dist: pgvector (>=0.2.1,<0.3.0)
 Requires-Dist: pillow (>=9.3.0)
-Requires-Dist: pixeltable-pgserver (==0.2.8)
+Requires-Dist: pixeltable-pgserver (==0.2.9)
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
 Requires-Dist: psycopg[binary] (>=3.1.18)
 Requires-Dist: puremagic (>=1.20)

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.2.28"
-__version_tuple__ = (0, 2, 28)
+__version__ = "0.2.29"
+__version_tuple__ = (0, 2, 29)

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/catalog/__init__.py

@@ -1,7 +1,7 @@
 from .catalog import Catalog
 from .column import Column
 from .dir import Dir
-from .globals import UpdateStatus, is_valid_identifier, is_valid_path, MediaValidation
+from .globals import UpdateStatus, is_valid_identifier, is_valid_path, MediaValidation, IfExistsParam
 from .insertable_table import InsertableTable
 from .named_function import NamedFunction
 from .path import Path

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/catalog/dir.py

@@ -21,6 +21,12 @@ class Dir(SchemaObject):
     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 _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-0.2.28 → pixeltable-0.2.29}/pixeltable/catalog/globals.py

@@ -51,6 +51,19 @@ class MediaValidation(enum.Enum):
             val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__.keys())
             raise excs.Error(f'{error_prefix} must be one of: [{val_strs}]')
 
+class IfExistsParam(enum.Enum):
+    ERROR = 0
+    IGNORE = 1
+    REPLACE = 2
+    REPLACE_FORCE = 3
+
+    @classmethod
+    def validated(cls, param_val: str, param_name: str) -> IfExistsParam:
+        try:
+            return cls[param_val.upper()]
+        except KeyError:
+            val_strs = ', '.join(f'{s.lower()!r}' for s in cls.__members__.keys())
+            raise excs.Error(f'{param_name} must be one of: [{val_strs}]')
 
 def is_valid_identifier(name: str) -> bool:
     return name.isidentifier() and not name.startswith('_')

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/catalog/named_function.py

@@ -25,6 +25,10 @@ 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-0.2.28 → pixeltable-0.2.29}/pixeltable/catalog/path_dict.py

@@ -51,11 +51,41 @@ class PathDict:
             record_dir(dir)
 
     def _resolve_path(self, path: Path) -> SchemaObject:
+        """Resolve the path to a SchemaObject.
+
+        Args:
+            path: path to resolve
+
+        Returns:
+            SchemaObject at the path.
+
+        Raises:
+            Error if path is invalid or does not exist.
+        """
+        schema_obj = self.get_object(path)
+        if schema_obj is None:
+            raise excs.Error(f"No such path: {str(path)}")
+        return schema_obj
+
+    def get_object(self, path: Path) -> Optional[SchemaObject]:
+        """Get the object at the given path, if any.
+
+        Args:
+            path: path to object
+
+        Returns:
+            SchemaObject at the path if it exists, None otherwise.
+
+        Raises:
+            Error if path is invalid.
+        """
         if path.is_root:
             return self.root_dir
         dir = self.root_dir
         for i, component in enumerate(path.components):
             if component not in self.dir_contents[dir._id]:
+                if i == len(path.components) - 1:
+                    return None
                 raise excs.Error(f'No such path: {".".join(path.components[:i + 1])}')
             schema_obj = self.dir_contents[dir._id][component]
             if i < len(path.components) - 1:
@@ -112,19 +142,15 @@ class PathDict:
             Error if path is invalid or object at path has wrong type
         """
         # check for existence
+        obj = self.get_object(path)
         if expected is not None:
-            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()}')
-        if expected is None:
-            parent_obj = self._resolve_path(path.parent)
-            if not isinstance(parent_obj, Dir):
+            if obj is None:
+                raise excs.Error(f"No such path: {str(path)}")
+            if not isinstance(obj, expected):
                 raise excs.Error(
-                    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")
+                    f'{str(path)} needs to be a {expected._display_name()} but is a {type(obj)._display_name()}')
+        if expected is None and obj is not None:
+            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)

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/catalog/schema_object.py

@@ -66,7 +66,13 @@ 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
+

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/catalog/table.py

@@ -63,6 +63,11 @@ class Table(SchemaObject):
                 return self._queries[name]
             raise AttributeError(f'Table {self.__table._name!r} has no query with that name: {name!r}')
 
+    @property
+    def _has_dependents(self) -> bool:
+        """Returns True if this table has any dependent views, or snapshots."""
+        return len(self._get_views(recursive=False)) > 0
+
     def _move(self, new_name: str, new_dir_id: UUID) -> None:
         self._check_is_dropped()
         super()._move(new_name, new_dir_id)
@@ -184,26 +189,38 @@ class Table(SchemaObject):
         return self.__query_scope
 
     def select(self, *items: Any, **named_items: Any) -> 'pxt.DataFrame':
-        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
+        """ Select columns or expressions from this table.
+
+        See [`DataFrame.select`][pixeltable.DataFrame.select] for more details.
+        """
         return self._df().select(*items, **named_items)
 
     def where(self, pred: 'exprs.Expr') -> 'pxt.DataFrame':
-        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
+        """Filter rows from this table based on the expression.
+
+        See [`DataFrame.where`][pixeltable.DataFrame.where] for more details.
+        """
         return self._df().where(pred)
 
     def join(
             self, other: 'Table', *, on: Optional['exprs.Expr'] = None,
             how: 'pixeltable.plan.JoinType.LiteralType' = 'inner'
     ) -> 'pxt.DataFrame':
-        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
+        """Join this table with another table."""
         return self._df().join(other, on=on, how=how)
 
     def order_by(self, *items: 'exprs.Expr', asc: bool = True) -> 'pxt.DataFrame':
-        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
+        """Order the rows of this table based on the expression.
+
+        See [`DataFrame.order_by`][pixeltable.DataFrame.order_by] for more details.
+        """
         return self._df().order_by(*items, asc=asc)
 
     def group_by(self, *items: 'exprs.Expr') -> 'pxt.DataFrame':
-        """Return a [`DataFrame`][pixeltable.DataFrame] for this table."""
+        """Group the rows of this table based on the expression.
+
+        See [`DataFrame.group_by`][pixeltable.DataFrame.group_by] for more details.
+        """
         return self._df().group_by(*items)
 
     def limit(self, n: int) -> 'pxt.DataFrame':

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/catalog/table_version.py

@@ -9,6 +9,7 @@ import uuid
 from typing import TYPE_CHECKING, Any, Iterable, Iterator, Literal, Optional
 from uuid import UUID
 
+import jsonschema.exceptions
 import sqlalchemy as sql
 import sqlalchemy.orm as orm
 
@@ -173,6 +174,14 @@ class TableVersion:
     def __hash__(self) -> int:
         return hash(self.id)
 
+    def _get_column(self, tbl_id: UUID, col_id: int) -> Column:
+        if self.id == tbl_id:
+            return self.cols_by_id[col_id]
+        else:
+            if self.base is None:
+                raise excs.Error(f'Unknown table id: {tbl_id}')
+            return self.base._get_column(tbl_id, col_id)
+
     def create_snapshot_copy(self) -> TableVersion:
         """Create a snapshot copy of this TableVersion"""
         assert not self.is_snapshot
@@ -335,7 +344,7 @@ class TableVersion:
             # instantiate index object
             cls_name = md.class_fqn.rsplit('.', 1)[-1]
             cls = getattr(index_module, cls_name)
-            idx_col = self.cols_by_id[md.indexed_col_id]
+            idx_col = self._get_column(UUID(md.indexed_col_tbl_id), md.indexed_col_id)
             idx = cls.from_dict(idx_col, md.init_args)
 
             # fix up the sa column type of the index value and undo columns
@@ -457,7 +466,8 @@ class TableVersion:
         idx_cls = type(idx)
         idx_md = schema.IndexMd(
             id=idx_id, name=idx_name,
-            indexed_col_id=col.id, index_val_col_id=val_col.id, index_val_undo_col_id=undo_col.id,
+            indexed_col_id=col.id, indexed_col_tbl_id=str(col.tbl.id),
+            index_val_col_id=val_col.id, index_val_undo_col_id=undo_col.id,
             schema_version_add=self.schema_version, schema_version_drop=None,
             class_fqn=idx_cls.__module__ + '.' + idx_cls.__name__, init_args=idx.as_dict())
         idx_info = self.IndexInfo(id=idx_id, name=idx_name, idx=idx, col=col, val_col=val_col, undo_col=undo_col)
@@ -485,7 +495,10 @@ class TableVersion:
         idx_md.schema_version_drop = self.schema_version
         assert idx_md.name in self.idxs_by_name
         idx_info = self.idxs_by_name[idx_md.name]
+        # remove this index entry from the active indexes (in memory)
+        # and the index metadata (in persistent table metadata)
         del self.idxs_by_name[idx_md.name]
+        del self.idx_md[idx_id]
 
         with Env.get().engine.begin() as conn:
             self._drop_columns([idx_info.val_col, idx_info.undo_col])
@@ -819,7 +832,7 @@ class TableVersion:
                 if error_if_not_exists:
                     raise excs.Error(f'batch_update(): {len(unmatched_rows)} row(s) not found')
                 if insert_if_not_exists:
-                    insert_status = self.insert(unmatched_rows, None, print_stats=False, fail_on_exception=False)
+                    insert_status = self.insert(unmatched_rows, None, conn=conn, print_stats=False, fail_on_exception=False)
                     result += insert_status
             return result
 
@@ -846,10 +859,11 @@ class TableVersion:
                 raise excs.Error(f'Column {col_name} is a primary key column and cannot be updated')
 
             # make sure that the value is compatible with the column type
+            value_expr: exprs.Expr
             try:
                 # check if this is a literal
-                value_expr: exprs.Expr = exprs.Literal(val, col_type=col.col_type)
-            except TypeError:
+                value_expr = exprs.Literal(val, col_type=col.col_type)
+            except (TypeError, jsonschema.exceptions.ValidationError):
                 if not allow_exprs:
                     raise excs.Error(
                         f'Column {col_name}: value {val!r} is not a valid literal for this column '
@@ -858,11 +872,11 @@ class TableVersion:
                 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((
+                if not col.col_type.is_supertype_of(value_expr.col_type, ignore_nullable=True):
+                    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

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/dataframe.py

@@ -300,6 +300,20 @@ class DataFrame:
         return self.limit(n).collect()
 
     def head(self, n: int = 10) -> DataFrameResultSet:
+        """Return the first n rows of the DataFrame, in insertion order of the underlying Table.
+
+        head() is not supported for joins.
+
+        Args:
+            n: Number of rows to select. Default is 10.
+
+        Returns:
+            A DataFrameResultSet with the first n rows of the DataFrame.
+
+        Raises:
+            Error: If the DataFrame is the result of a join or
+                if the DataFrame has an order_by clause.
+        """
         if self.order_by_clause is not None:
             raise excs.Error(f'head() cannot be used with order_by()')
         if self._has_joins():
@@ -309,6 +323,20 @@ class DataFrame:
         return self.order_by(*order_by_clause, asc=True).limit(n).collect()
 
     def tail(self, n: int = 10) -> DataFrameResultSet:
+        """Return the last n rows of the DataFrame, in insertion order of the underlying Table.
+
+        tail() is not supported for joins.
+
+        Args:
+            n: Number of rows to select. Default is 10.
+
+        Returns:
+            A DataFrameResultSet with the last n rows of the DataFrame.
+
+        Raises:
+            Error: If the DataFrame is the result of a join or
+                if the DataFrame has an order_by clause.
+        """
         if self.order_by_clause is not None:
             raise excs.Error(f'tail() cannot be used with order_by()')
         if self._has_joins():
@@ -394,6 +422,11 @@ class DataFrame:
         return DataFrameResultSet(list(self._output_row_iterator(conn)), self.schema)
 
     def count(self) -> int:
+        """Return the number of rows in the DataFrame.
+
+        Returns:
+            The number of rows in the DataFrame.
+        """
         from pixeltable.plan import Planner
 
         stmt = Planner.create_count_stmt(self._first_tbl, self.where_clause)
@@ -463,6 +496,36 @@ class DataFrame:
         return self._descriptors().to_html()
 
     def select(self, *items: Any, **named_items: Any) -> DataFrame:
+        """ Select columns or expressions from the DataFrame.
+
+        Args:
+            items: expressions to be selected
+            named_items: named expressions to be selected
+
+        Returns:
+            A new DataFrame with the specified select list.
+
+        Raises:
+            Error: If the select list is already specified,
+                or if any of the specified expressions are invalid,
+                or refer to tables not in the DataFrame.
+
+        Examples:
+            Given the DataFrame person from a table t with all its columns and rows:
+
+            >>> person = t.select()
+
+            Select the columns 'name' and 'age' (referenced in table t) from the DataFrame person:
+
+            >>> df = person.select(t.name, t.age)
+
+            Select the columns 'name' (referenced in table t) from the DataFrame person,
+            and a named column 'is_adult' from the expression `age >= 18` where 'age' is
+            another column in table t:
+
+            >>> df = person.select(t.name, is_adult=(t.age >= 18))
+
+        """
         if self.select_list is not None:
             raise excs.Error(f'Select list already specified')
         for name, _ in named_items.items():
@@ -512,6 +575,29 @@ class DataFrame:
         )
 
     def where(self, pred: exprs.Expr) -> DataFrame:
+        """Filter rows based on a predicate.
+
+        Args:
+            pred: the predicate to filter rows
+
+        Returns:
+            A new DataFrame with the specified predicates replacing the where-clause.
+
+        Raises:
+            Error: If the predicate is not a Pixeltable expression,
+                or if it does not return a boolean value,
+                or refers to tables not in the DataFrame.
+
+        Examples:
+            Given the DataFrame person from a table t with all its columns and rows:
+
+            >>> person = t.select()
+
+            Filter the above DataFrame person to only include rows where the column 'age'
+            (referenced in table t) is greater than 30:
+
+            >>> df = person.where(t.age > 30)
+        """
         if not isinstance(pred, exprs.Expr):
             raise excs.Error(f'Where() requires a Pixeltable expression, but instead got {type(pred)}')
         if not pred.col_type.is_bool_type():
@@ -662,11 +748,45 @@ class DataFrame:
         )
 
     def group_by(self, *grouping_items: Any) -> DataFrame:
-        """
-        Add a group-by clause to this DataFrame.
+        """ Add a group-by clause to this DataFrame.
+
         Variants:
         - group_by(<base table>): group a component view by their respective base table rows
         - group_by(<expr>, ...): group by the given expressions
+
+        Note, that grouping will be applied to the rows and take effect when
+        used with an aggregation function like sum(), count() etc.
+
+        Args:
+            grouping_items: expressions to group by
+
+        Returns:
+            A new DataFrame with the specified group-by clause.
+
+        Raises:
+            Error: If the group-by clause is already specified,
+                or if the specified expression is invalid,
+                or refer to tables not in the DataFrame,
+                or if the DataFrame is a result of a join.
+
+        Examples:
+            Given the DataFrame book from a table t with all its columns and rows:
+
+            >>> book = t.select()
+
+            Group the above DataFrame book by the 'genre' column (referenced in table t):
+
+            >>> df = book.group_by(t.genre)
+
+            Use the above DataFrame df grouped by genre to count the number of
+            books for each 'genre':
+
+            >>> df = book.group_by(t.genre).select(t.genre, count=count(t.genre)).show()
+
+            Use the above DataFrame df grouped by genre to the total price of
+            books for each 'genre':
+
+            >>> df = book.group_by(t.genre).select(t.genre, total=sum(t.price)).show()
         """
         if self.group_by_clause is not None:
             raise excs.Error(f'Group-by already specified')
@@ -699,6 +819,35 @@ class DataFrame:
         )
 
     def order_by(self, *expr_list: exprs.Expr, asc: bool = True) -> DataFrame:
+        """ Add an order-by clause to this DataFrame.
+
+        Args:
+            expr_list: expressions to order by
+            asc: whether to order in ascending order (True) or descending order (False).
+                Default is True.
+
+        Returns:
+            A new DataFrame with the specified order-by clause.
+
+        Raises:
+            Error: If the order-by clause is already specified,
+                or if the specified expression is invalid,
+                or refer to tables not in the DataFrame.
+
+        Examples:
+            Given the DataFrame book from a table t with all its columns and rows:
+
+            >>> book = t.select()
+
+            Order the above DataFrame book by two columns (price, pages) in descending order:
+
+            >>> df = book.order_by(t.price, t.pages, asc=False)
+
+            Order the above DataFrame book by price in descending order, but order the pages
+            in ascending order:
+
+            >>> df = book.order_by(t.price, asc=False).order_by(t.pages)
+        """
         for e in expr_list:
             if not isinstance(e, exprs.Expr):
                 raise excs.Error(f'Invalid expression in order_by(): {e}')
@@ -715,6 +864,14 @@ class DataFrame:
         )
 
     def limit(self, n: int) -> DataFrame:
+        """ Limit the number of rows in the DataFrame.
+
+        Args:
+            n: Number of rows to select.
+
+        Returns:
+            A new DataFrame with the specified limited rows.
+        """
         # TODO: allow n to be a Variable that can be substituted in bind()
         assert n is not None and isinstance(n, int)
         return DataFrame(
@@ -728,17 +885,58 @@ class DataFrame:
         )
 
     def update(self, value_spec: dict[str, Any], cascade: bool = True) -> UpdateStatus:
+        """ Update rows in the underlying table of the DataFrame.
+
+        Update rows in the table with the specified value_spec.
+
+        Args:
+            value_spec: a dict of column names to update and the new value to update it to.
+            cascade: if True, also update all computed columns that transitively depend
+                    on the updated columns, including within views. Default is True.
+
+        Returns:
+            UpdateStatus: the status of the update operation.
+
+        Example:
+            Given the DataFrame person from a table t with all its columns and rows:
+
+            >>> person = t.select()
+
+            Via the above DataFrame person, update the column 'city' to 'Oakland' and 'state' to 'CA' in the table t:
+
+            >>> df = person.update({'city': 'Oakland', 'state': 'CA'})
+
+            Via the above DataFrame person, update the column 'age' to 30 for any rows where 'year' is 2014 in the table t:
+
+            >>> df = person.where(t.year == 2014).update({'age': 30})
+        """
         self._validate_mutable('update')
         return self._first_tbl.tbl_version.update(value_spec, where=self.where_clause, cascade=cascade)
 
     def delete(self) -> UpdateStatus:
+        """ Delete rows form the underlying table of the DataFrame.
+
+        The delete operation is only allowed for DataFrames on base tables.
+
+        Returns:
+            UpdateStatus: the status of the delete operation.
+
+        Example:
+            Given the DataFrame person from a table t with all its columns and rows:
+
+            >>> person = t.select()
+
+            Via the above DataFrame person, delete all rows from the table t where the column 'age' is less than 18:
+
+            >>> df = person.where(t.age < 18).delete()
+        """
         self._validate_mutable('delete')
         if not self._first_tbl.is_insertable():
             raise excs.Error(f'Cannot delete from view')
         return self._first_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)."""
+        """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:

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/env.py

@@ -8,6 +8,7 @@ import importlib.util
 import inspect
 import logging
 import os
+import platform
 import shutil
 import subprocess
 import sys
@@ -311,8 +312,12 @@ class Env:
         self._db_name = os.environ.get('PIXELTABLE_DB', 'pixeltable')
         self._pgdata_dir = Path(os.environ.get('PIXELTABLE_PGDATA', str(self._home / 'pgdata')))
 
-        # in pixeltable_pgserver.get_server(): cleanup_mode=None will leave db on for debugging purposes
-        self._db_server = pixeltable_pgserver.get_server(self._pgdata_dir, cleanup_mode=None)
+        # cleanup_mode=None will leave the postgres process running after Python exits
+        # cleanup_mode='stop' will terminate the postgres process when Python exits
+        # On Windows, we need cleanup_mode='stop' because child processes are killed automatically when the parent
+        # process (such as Terminal or VSCode) exits, potentially leaving it in an unusable state.
+        cleanup_mode = 'stop' if platform.system() == 'Windows' else None
+        self._db_server = pixeltable_pgserver.get_server(self._pgdata_dir, cleanup_mode=cleanup_mode)
         self._db_url = self._db_server.get_uri(database=self._db_name, driver='psycopg')
 
         tz_name = self.config.get_string_value('time_zone')
@@ -357,7 +362,7 @@ class Env:
             self.db_url,
             echo=echo,
             future=True,
-            isolation_level='AUTOCOMMIT',
+            isolation_level='REPEATABLE READ',
             connect_args=connect_args,
         )
         self._logger.info(f'Created SQLAlchemy engine at: {self.db_url}')
@@ -506,6 +511,7 @@ class Env:
         self.__register_package('openai')
         self.__register_package('openpyxl')
         self.__register_package('pyarrow')
+        self.__register_package('pydantic')
         self.__register_package('replicate')
         self.__register_package('sentencepiece')
         self.__register_package('sentence_transformers', library_name='sentence-transformers')

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/exec/expr_eval_node.py

@@ -208,7 +208,7 @@ class ExprEvalNode(ExecNode):
                         }
                         start_ts = time.perf_counter()
                         assert isinstance(fn_call.fn, CallableFunction)
-                        result_batch = fn_call.fn.exec_batch(*call_args, **call_kwargs)
+                        result_batch = fn_call.fn.exec_batch(call_args, call_kwargs)
                         self.ctx.profile.eval_time[fn_call.slot_idx] += time.perf_counter() - start_ts
                         self.ctx.profile.eval_count[fn_call.slot_idx] += num_ext_batch_rows
 

{pixeltable-0.2.28 → pixeltable-0.2.29}/pixeltable/exec/sql_node.py

@@ -262,7 +262,7 @@ class SqlNode(ExecNode):
             explain_str = '\n'.join([str(row) for row in explain_result])
             _logger.debug(f'SqlScanNode explain:\n{explain_str}')
         except Exception as e:
-            _logger.warning(f'EXPLAIN failed')
+            _logger.warning(f'EXPLAIN failed with error: {e}')
 
     def __iter__(self) -> Iterator[DataRowBatch]:
         # run the query; do this here rather than in _open(), exceptions are only expected during iteration
@@ -468,4 +468,4 @@ class SqlJoinNode(SqlNode):
             stmt = stmt.join(
                 self.input_ctes[i + 1], onclause=on_clause, isouter=is_outer,
                 full=join_clause == plan.JoinType.FULL_OUTER)
-        return stmt
+        return stmt