pixeltable 0.2.24__tar.gz → 0.2.25__tar.gz

{pixeltable-0.2.24 → pixeltable-0.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.2.24
+Version: 0.2.25
 Summary: Pixeltable: The Multimodal AI Data Plane
 Author: Pixeltable, Inc.
 Author-email: contact@pixeltable.com
@@ -40,7 +40,7 @@ Description-Content-Type: text/markdown
      alt="Pixeltable" width="50%" />
 <br></br>
 
-<h2>AI Data Insfrastructure — Declarative, Multimodal, and Incremental</h2>
+<h2>AI Data Infrastructure — Declarative, Multimodal, and Incremental</h2>
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-0530AD.svg)](https://opensource.org/licenses/Apache-2.0)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pixeltable?logo=python&logoColor=white&)
@@ -48,8 +48,8 @@ Description-Content-Type: text/markdown
 <br>
 [![tests status](https://github.com/pixeltable/pixeltable/actions/workflows/pytest.yml/badge.svg)](https://github.com/pixeltable/pixeltable/actions/workflows/pytest.yml)
 [![tests status](https://github.com/pixeltable/pixeltable/actions/workflows/nightly.yml/badge.svg)](https://github.com/pixeltable/pixeltable/actions/workflows/nightly.yml)
-[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fpixeltable%2Fpixeltable.svg?type=shield&issueType=security)](https://app.fossa.com/projects/git%2Bgithub.com%2Fpixeltable%2Fpixeltable?ref=badge_shield&issueType=security)
 [![PyPI Package](https://img.shields.io/pypi/v/pixeltable?color=4D148C)](https://pypi.org/project/pixeltable/)
+[![My Discord (1306431018890166272)](https://img.shields.io/badge/💬-Discord-%235865F2.svg)](https://discord.gg/QPyqFYx2UN)
 <a target="_blank" href="https://huggingface.co/Pixeltable">
   <img src="https://img.shields.io/badge/🤗-HF Space-FF7D04" alt="Visit our Hugging Face space"/>
 </a>

{pixeltable-0.2.24 → pixeltable-0.2.25}/README.md

@@ -3,7 +3,7 @@
      alt="Pixeltable" width="50%" />
 <br></br>
 
-<h2>AI Data Insfrastructure — Declarative, Multimodal, and Incremental</h2>
+<h2>AI Data Infrastructure — Declarative, Multimodal, and Incremental</h2>
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-0530AD.svg)](https://opensource.org/licenses/Apache-2.0)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pixeltable?logo=python&logoColor=white&)
@@ -11,8 +11,8 @@
 <br>
 [![tests status](https://github.com/pixeltable/pixeltable/actions/workflows/pytest.yml/badge.svg)](https://github.com/pixeltable/pixeltable/actions/workflows/pytest.yml)
 [![tests status](https://github.com/pixeltable/pixeltable/actions/workflows/nightly.yml/badge.svg)](https://github.com/pixeltable/pixeltable/actions/workflows/nightly.yml)
-[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fpixeltable%2Fpixeltable.svg?type=shield&issueType=security)](https://app.fossa.com/projects/git%2Bgithub.com%2Fpixeltable%2Fpixeltable?ref=badge_shield&issueType=security)
 [![PyPI Package](https://img.shields.io/pypi/v/pixeltable?color=4D148C)](https://pypi.org/project/pixeltable/)
+[![My Discord (1306431018890166272)](https://img.shields.io/badge/💬-Discord-%235865F2.svg)](https://discord.gg/QPyqFYx2UN)
 <a target="_blank" href="https://huggingface.co/Pixeltable">
   <img src="https://img.shields.io/badge/🤗-HF Space-FF7D04" alt="Visit our Hugging Face space"/>
 </a>

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.2.24"
-__version_tuple__ = (0, 2, 24)
+__version__ = "0.2.25"
+__version_tuple__ = (0, 2, 25)

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/catalog/table.py

@@ -28,6 +28,7 @@ from .globals import _ROWID_COLUMN_NAME, UpdateStatus, is_system_column_name, is
 from .schema_object import SchemaObject
 from .table_version import TableVersion
 from .table_version_path import TableVersionPath
+from ..exprs import ColumnRef
 
 if TYPE_CHECKING:
     import torch.utils.data
@@ -199,6 +200,7 @@ class Table(SchemaObject):
     ) -> 'pxt.dataframe.DataFrameResultSet':
         """Return rows from this table.
         """
+        self._check_is_dropped()
         return self._df().show(*args, **kwargs)
 
     def head(
@@ -298,6 +300,10 @@ class Table(SchemaObject):
         return self._description_html()._repr_html_()  # type: ignore[attr-defined]
 
     def _drop(self) -> None:
+        cat = catalog.Catalog.get()
+        # verify all dependents are deleted by now
+        for dep in cat.tbl_dependents[self._id]:
+            assert dep._is_dropped
         self._check_is_dropped()
         self._tbl_version.drop()
         self._is_dropped = True
@@ -598,31 +604,49 @@ class Table(SchemaObject):
             cls._verify_column(col, column_names)
             column_names.add(col.name)
 
-    def drop_column(self, name: str) -> None:
+    def __check_column_name_exists(self, column_name: str, include_bases: bool = False) -> None:
+        col = self._tbl_version_path.get_column(column_name, include_bases)
+        if col is None:
+            raise excs.Error(f'Column {column_name!r} unknown')
+
+    def __check_column_ref_exists(self, col_ref: ColumnRef, include_bases: bool = False) -> None:
+        exists = self._tbl_version_path.has_column(col_ref.col, include_bases)
+        if not exists:
+            raise excs.Error(f'Unknown column: {col_ref.col.qualified_name}')
+
+    def drop_column(self, column: Union[str, ColumnRef]) -> None:
         """Drop a column from the table.
 
         Args:
-            name: The name of the column to drop.
+            column: The name or reference of the column to drop.
 
         Raises:
             Error: If the column does not exist or if it is referenced by a dependent computed column.
 
         Examples:
-            Drop the column `col` from the table `my_table`:
+            Drop the column `col` from the table `my_table` by column name:
 
             >>> tbl = pxt.get_table('my_table')
             ... tbl.drop_column('col')
+
+            Drop the column `col` from the table `my_table` by column reference:
+
+            >>> tbl = pxt.get_table('my_table')
+            ... tbl.drop_column(tbl.col)
         """
         self._check_is_dropped()
-
-        if name not in self._tbl_version.cols_by_name:
-            raise excs.Error(f'Unknown column: {name}')
-        col = self._tbl_version.cols_by_name[name]
+        col: Column = None
+        if isinstance(column, str):
+            self.__check_column_name_exists(column)
+            col = self._tbl_version.cols_by_name[column]
+        else:
+            self.__check_column_ref_exists(column)
+            col = column.col
 
         dependent_user_cols = [c for c in col.dependent_cols if c.name is not None]
         if len(dependent_user_cols) > 0:
             raise excs.Error(
-                f'Cannot drop column `{name}` because the following columns depend on it:\n'
+                f'Cannot drop column `{col.name}` because the following columns depend on it:\n'
                 f'{", ".join(c.name for c in dependent_user_cols)}'
             )
 
@@ -640,7 +664,7 @@ class Table(SchemaObject):
                 for view, store in dependent_stores
             ]
             raise excs.Error(
-                f'Cannot drop column `{name}` because the following external stores depend on it:\n'
+                f'Cannot drop column `{col.name}` because the following external stores depend on it:\n'
                 f'{", ".join(dependent_store_names)}'
             )
 
@@ -666,7 +690,7 @@ class Table(SchemaObject):
         self._tbl_version.rename_column(old_name, new_name)
 
     def add_embedding_index(
-            self, col_name: str, *, idx_name: Optional[str] = None,
+            self, column: Union[str, ColumnRef], *, idx_name: Optional[str] = None,
             string_embed: Optional[pxt.Function] = None, image_embed: Optional[pxt.Function] = None,
             metric: str = 'cosine'
     ) -> None:
@@ -680,7 +704,7 @@ class Table(SchemaObject):
         of text over an image column.
 
         Args:
-            col_name: The name of column to index; must be a `String` or `Image` column.
+            column: The name of, or reference to, the column to index; must be a `String` or `Image` column.
             idx_name: The name of index. If not specified, a name such as `'idx0'` will be generated automatically.
                 If specified, the name must be unique for this table.
             string_embed: A function to embed text; required if the column is a `String` column.
@@ -692,11 +716,15 @@ class Table(SchemaObject):
             Error: If an index with that name already exists for the table, or if the specified column does not exist.
 
         Examples:
-            Add an index to the `img` column of the table `my_table`:
+            Add an index to the `img` column of the table `my_table` by column name:
 
             >>> tbl = pxt.get_table('my_table')
             ... tbl.add_embedding_index('img', image_embed=my_image_func)
 
+            Add an index to the `img` column of the table `my_table` by column reference:
+            >>> tbl = pxt.get_table('my_table')
+            ... tbl.add_embedding_index(tbl.img, image_embed=my_image_func)
+
             Add another index to the `img` column, using the inner product as the distance metric,
             and with a specific name; `string_embed` is also specified in order to search with text:
 
@@ -707,13 +735,28 @@ class Table(SchemaObject):
             ...     string_embed=my_string_func,
             ...     metric='ip'
             ... )
+
+            Alternatively:
+
+            >>> tbl.add_embedding_index(
+            ...     tbl.img,
+            ...     idx_name='clip_idx',
+            ...     image_embed=my_image_func,
+            ...     string_embed=my_string_func,
+            ...     metric='ip'
+            ... )
         """
         if self._tbl_version_path.is_snapshot():
             raise excs.Error('Cannot add an index to a snapshot')
         self._check_is_dropped()
-        col = self._tbl_version_path.get_column(col_name, include_bases=True)
-        if col is None:
-            raise excs.Error(f'Column {col_name} unknown')
+        col: Column
+        if isinstance(column, str):
+            self.__check_column_name_exists(column, include_bases=True)
+            col = self._tbl_version_path.get_column(column, include_bases=True)
+        else:
+            self.__check_column_ref_exists(column, include_bases=True)
+            col = column.col
+
         if idx_name is not None and idx_name in self._tbl_version.idxs_by_name:
             raise excs.Error(f'Duplicate index name: {idx_name}')
         from pixeltable.index import EmbeddingIndex
@@ -724,82 +767,129 @@ class Table(SchemaObject):
         # TODO: how to deal with exceptions here? drop the index and raise?
         FileCache.get().emit_eviction_warnings()
 
-    def drop_embedding_index(self, *, column_name: Optional[str] = None, idx_name: Optional[str] = None) -> None:
+    def drop_embedding_index(
+            self, *,
+            column: Union[str, ColumnRef, None] = None,
+            idx_name: Optional[str] = None) -> None:
         """
         Drop an embedding index from the table. Either a column name or an index name (but not both) must be
-        specified. If a column name is specified, it must be a column containing exactly one embedding index;
-        otherwise the specific index name must be provided instead.
+        specified. If a column name or reference is specified, it must be a column containing exactly one
+        embedding index; otherwise the specific index name must be provided instead.
 
         Args:
-            column_name: The name of the column from which to drop the index. Invalid if the column has multiple
-                embedding indices.
+            column: The name of, or reference to, the column from which to drop the index.
+                    The column must have only one embedding index.
             idx_name: The name of the index to drop.
 
         Raises:
-            Error: If `column_name` is specified, but the column does not exist, or it contains no embedding
+            Error: If `column` is specified, but the column does not exist, or it contains no embedding
                 indices or multiple embedding indices.
             Error: If `idx_name` is specified, but the index does not exist or is not an embedding index.
 
         Examples:
-            Drop the embedding index on the `img` column of the table `my_table`:
+            Drop the embedding index on the `img` column of the table `my_table` by column name:
 
             >>> tbl = pxt.get_table('my_table')
-            ... tbl.drop_embedding_index(column_name='img')
-        """
-        self._drop_index(column_name=column_name, idx_name=idx_name, _idx_class=index.EmbeddingIndex)
+            ... tbl.drop_embedding_index(column='img')
+
+            Drop the embedding index on the `img` column of the table `my_table` by column reference:
+
+            >>> tbl = pxt.get_table('my_table')
+            ... tbl.drop_embedding_index(column=tbl.img)
+
+            Drop the embedding index `idx1` of the table `my_table` by index name:
+            >>> tbl = pxt.get_table('my_table')
+            ... tbl.drop_embedding_index(idx_name='idx1')
 
-    def drop_index(self, *, column_name: Optional[str] = None, idx_name: Optional[str] = None) -> None:
+        """
+        if (column is None) == (idx_name is None):
+            raise excs.Error("Exactly one of 'column' or 'idx_name' must be provided")
+
+        col: Column = None
+        if idx_name is None:
+            if isinstance(column, str):
+                self.__check_column_name_exists(column, include_bases=True)
+                col = self._tbl_version_path.get_column(column, include_bases=True)
+            else:
+                self.__check_column_ref_exists(column, include_bases=True)
+                col = column.col
+            assert col is not None
+        self._drop_index(col=col, idx_name=idx_name, _idx_class=index.EmbeddingIndex)
+
+    def drop_index(
+            self, *,
+            column: Union[str, ColumnRef, None] = None,
+            idx_name: Optional[str] = None) -> None:
         """
         Drop an index from the table. Either a column name or an index name (but not both) must be
-        specified. If a column name is specified, it must be a column containing exactly one index;
+        specified. If a column name or reference is specified, it must be a column containing exactly one index;
         otherwise the specific index name must be provided instead.
 
         Args:
-            column_name: The name of the column from which to drop the index. Invalid if the column has multiple
-                indices.
+            column: The name of, or reference to, the column from which to drop the index.
+                    The column must have only one embedding index.
             idx_name: The name of the index to drop.
 
         Raises:
-            Error: If `column_name` is specified, but the column does not exist, or it contains no
+            Error: If `column` is specified, but the column does not exist, or it contains no
                 indices or multiple indices.
             Error: If `idx_name` is specified, but the index does not exist.
 
         Examples:
-            Drop the index on the `img` column of the table `my_table`:
+            Drop the index on the `img` column of the table `my_table` by column name:
 
             >>> tbl = pxt.get_table('my_table')
             ... tbl.drop_index(column_name='img')
+
+            Drop the index on the `img` column of the table `my_table` by column reference:
+
+            >>> tbl = pxt.get_table('my_table')
+            ... tbl.drop_index(tbl.img)
+
+            Drop the index `idx1` of the table `my_table` by index name:
+            >>> tbl = pxt.get_table('my_table')
+            ... tbl.drop_index(idx_name='idx1')
+
         """
-        self._drop_index(column_name=column_name, idx_name=idx_name)
+        if (column is None) == (idx_name is None):
+            raise excs.Error("Exactly one of 'column' or 'idx_name' must be provided")
+
+        col: Column = None
+        if idx_name is None:
+            if isinstance(column, str):
+                self.__check_column_name_exists(column, include_bases=True)
+                col = self._tbl_version_path.get_column(column, include_bases=True)
+            else:
+                self.__check_column_ref_exists(column, include_bases=True)
+                col = column.col
+            assert col is not None
+        self._drop_index(col=col, idx_name=idx_name)
 
     def _drop_index(
-            self, *, column_name: Optional[str] = None, idx_name: Optional[str] = None,
+            self, *, col: Optional[Column] = None,
+            idx_name: Optional[str] = None,
             _idx_class: Optional[type[index.IndexBase]] = None
     ) -> None:
         if self._tbl_version_path.is_snapshot():
             raise excs.Error('Cannot drop an index from a snapshot')
         self._check_is_dropped()
-        if (column_name is None) == (idx_name is None):
-            raise excs.Error("Exactly one of 'column_name' or 'idx_name' must be provided")
+        assert (col is None) != (idx_name is None)
 
         if idx_name is not None:
             if idx_name not in self._tbl_version.idxs_by_name:
                 raise excs.Error(f'Index {idx_name!r} does not exist')
             idx_id = self._tbl_version.idxs_by_name[idx_name].id
         else:
-            col = self._tbl_version_path.get_column(column_name, include_bases=True)
-            if col is None:
-                raise excs.Error(f'Column {column_name!r} unknown')
             if col.tbl.id != self._tbl_version.id:
                 raise excs.Error(
-                    f'Column {column_name!r}: cannot drop index from column that belongs to base ({col.tbl.name}!r)')
+                    f'Column {col.name!r}: cannot drop index from column that belongs to base ({col.tbl.name}!r)')
             idx_info = [info for info in self._tbl_version.idxs_by_name.values() if info.col.id == col.id]
             if _idx_class is not None:
                 idx_info = [info for info in idx_info if isinstance(info.idx, _idx_class)]
             if len(idx_info) == 0:
-                raise excs.Error(f'Column {column_name!r} does not have an index')
+                raise excs.Error(f'Column {col.name!r} does not have an index')
             if len(idx_info) > 1:
-                raise excs.Error(f"Column {column_name!r} has multiple indices; specify 'idx_name' instead")
+                raise excs.Error(f"Column {col.name!r} has multiple indices; specify 'idx_name' instead")
             idx_id = idx_info[0].id
         self._tbl_version.drop_index(idx_id)
 

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/catalog/view.py

@@ -194,6 +194,9 @@ class View(Table):
 
     def _drop(self) -> None:
         cat = catalog.Catalog.get()
+        # verify all dependents are deleted by now
+        for dep in cat.tbl_dependents[self._id]:
+            assert dep._is_dropped
         if self._snapshot_only:
             # there is not TableVersion to drop
             self._check_is_dropped()

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/exprs/similarity_expr.py

@@ -58,6 +58,9 @@ class SimilarityExpr(Expr):
     def __str__(self) -> str:
         return f'{self.components[0]}.similarity({self.components[1]})'
 
+    def default_column_name(self) -> str:
+        return 'similarity'
+
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not isinstance(self.components[1], Literal):
              raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/func/function.py

@@ -3,16 +3,20 @@ from __future__ import annotations
 import abc
 import importlib
 import inspect
-from typing import Any, Callable, Optional
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 import sqlalchemy as sql
 
 import pixeltable as pxt
+import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
 
 from .globals import resolve_symbol
 from .signature import Signature
 
+if TYPE_CHECKING:
+    from .expr_template_function import ExprTemplateFunction
+
 
 class Function(abc.ABC):
     """Base class for Pixeltable's function interface.
@@ -99,6 +103,38 @@ class Function(abc.ABC):
         self._conditional_return_type = fn
         return fn
 
+    def using(self, **kwargs: Any) -> 'ExprTemplateFunction':
+        from pixeltable import exprs
+
+        from .expr_template_function import ExprTemplateFunction
+
+        # Resolve each kwarg into a parameter binding
+        bindings: dict[str, exprs.Expr] = {}
+        for k, v in kwargs.items():
+            if k not in self.signature.parameters:
+                raise excs.Error(f'Unknown parameter: {k}')
+            param = self.signature.parameters[k]
+            expr = exprs.Expr.from_object(v)
+            if not param.col_type.is_supertype_of(expr.col_type):
+                raise excs.Error(f'Expected type `{param.col_type}` for parameter `{k}`; got `{expr.col_type}`')
+            bindings[k] = v  # Use the original value, not the Expr (The Expr is only for validation)
+
+        residual_params = [
+            p for p in self.signature.parameters.values() if p.name not in bindings
+        ]
+
+        # Bind each remaining parameter to a like-named variable
+        for param in residual_params:
+            bindings[param.name] = exprs.Variable(param.name, param.col_type)
+
+        call = exprs.FunctionCall(self, bindings)
+
+        # Construct the (n-k)-ary signature of the new function. We use `call.col_type` for this, rather than
+        # `self.signature.return_type`, because the return type of the new function may be specialized via a
+        # conditional return type.
+        new_signature = Signature(call.col_type, residual_params, self.signature.is_batched)
+        return ExprTemplateFunction(call, new_signature)
+
     @abc.abstractmethod
     def exec(self, *args: Any, **kwargs: Any) -> Any:
         """Execute the function with the given arguments and return the result."""

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/func/signature.py

@@ -91,6 +91,7 @@ class Signature:
         self.parameters_by_pos = parameters.copy()
         self.constant_parameters = [p for p in parameters if not p.is_batched]
         self.batched_parameters = [p for p in parameters if p.is_batched]
+        self.required_parameters = [p for p in parameters if not p.has_default()]
         self.py_signature = inspect.Signature([p.to_py_param() for p in self.parameters_by_pos])
 
     def get_return_type(self) -> ts.ColumnType:

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/functions/mistralai.py

@@ -36,7 +36,6 @@ def chat_completions(
     temperature: Optional[float] = 0.7,
     top_p: Optional[float] = 1.0,
     max_tokens: Optional[int] = None,
-    min_tokens: Optional[int] = None,
     stop: Optional[list[str]] = None,
     random_seed: Optional[int] = None,
     response_format: Optional[dict] = None,
@@ -75,7 +74,6 @@ def chat_completions(
         temperature=temperature,
         top_p=top_p,
         max_tokens=_opt(max_tokens),
-        min_tokens=_opt(min_tokens),
         stop=stop,
         random_seed=_opt(random_seed),
         response_format=response_format,  # type: ignore[arg-type]

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/globals.py

@@ -296,31 +296,42 @@ def move(path: str, new_path: str) -> None:
     obj._move(new_p.name, new_dir._id)
 
 
-def drop_table(path: str, force: bool = False, ignore_errors: bool = False) -> None:
+def drop_table(table: Union[str, catalog.Table], force: bool = False, ignore_errors: bool = False) -> None:
     """Drop a table, view, or snapshot.
 
     Args:
-        path: Path to the [`Table`][pixeltable.Table].
+        table: Fully qualified name, or handle, of the table to be dropped.
         force: If `True`, will also drop all views and sub-views of this table.
         ignore_errors: If `True`, return silently if the table does not exist (without throwing an exception).
 
     Raises:
-        Error: If the path does not exist or does not designate a table object, and `ignore_errors=False`.
+        Error: If the name does not exist or does not designate a table object, and `ignore_errors=False`.
 
     Examples:
-        >>> pxt.drop_table('my_table')
+        Drop a table by its fully qualified name:
+        >>> pxt.drop_table('subdir.my_table')
+
+        Drop a table by its handle:
+        >>> t = pxt.get_table('subdir.my_table')
+        ... pxt.drop_table(t)
+
     """
     cat = Catalog.get()
-    path_obj = catalog.Path(path)
-    try:
-        cat.paths.check_is_valid(path_obj, expected=catalog.Table)
-    except Exception as e:
-        if ignore_errors or force:
-            _logger.info(f'Skipped table `{path}` (does not exist).')
-            return
-        else:
-            raise e
-    tbl = cat.paths[path_obj]
+    if isinstance(table, str):
+        tbl_path_obj = catalog.Path(table)
+        try:
+            cat.paths.check_is_valid(tbl_path_obj, expected=catalog.Table)
+        except Exception as e:
+            if ignore_errors or force:
+                _logger.info(f'Skipped table `{table}` (does not exist).')
+                return
+            else:
+                raise e
+        tbl = cat.paths[tbl_path_obj]
+    else:
+        tbl = table
+        tbl_path_obj = catalog.Path(tbl._path)
+
     assert isinstance(tbl, catalog.Table)
     if len(cat.tbl_dependents[tbl._id]) > 0:
         dependent_paths = [dep._path for dep in cat.tbl_dependents[tbl._id]]
@@ -328,10 +339,10 @@ def drop_table(path: str, force: bool = False, ignore_errors: bool = False) -> N
             for dependent_path in dependent_paths:
                 drop_table(dependent_path, force=True)
         else:
-            raise excs.Error(f'Table {path} has dependents: {", ".join(dependent_paths)}')
+            raise excs.Error(f'Table {tbl._path} has dependents: {", ".join(dependent_paths)}')
     tbl._drop()
-    del cat.paths[path_obj]
-    _logger.info(f'Dropped table `{path}`.')
+    del cat.paths[tbl_path_obj]
+    _logger.info(f'Dropped table `{tbl._path}`.')
 
 
 def list_tables(dir_path: str = '', recursive: bool = True) -> list[str]:

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/index/embedding_index.py

@@ -136,7 +136,12 @@ class EmbeddingIndex(IndexBase):
         """Validate the signature"""
         assert isinstance(embed_fn, func.Function)
         sig = embed_fn.signature
-        if len(sig.parameters) != 1 or sig.parameters_by_pos[0].col_type.type_enum != expected_type:
+
+        # The embedding function must be a 1-ary function of the correct type. But it's ok if the function signature
+        # has more than one parameter, as long as it has at most one *required* parameter.
+        if (len(sig.parameters) == 0
+            or len(sig.required_parameters) > 1
+            or sig.parameters_by_pos[0].col_type.type_enum != expected_type):
             raise excs.Error(
                 f'{name} must take a single {expected_type.name.lower()} parameter, but has signature {sig}')
 

{pixeltable-0.2.24 → pixeltable-0.2.25}/pixeltable/iterators/__init__.py

@@ -1,5 +1,6 @@
 from .base import ComponentIterator
 from .document import DocumentSplitter
+from .image import TileIterator
 from .string import StringSplitter
 from .video import FrameIterator