pixeltable 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

pixeltable/__init__.py

@@ -1,18 +1,30 @@
 from .catalog import Column, Table, InsertableTable, View
-from .client import Client
 from .dataframe import DataFrame
 from .exceptions import Error, Error
 from .exprs import RELATIVE_PATH_ROOT
 from .func import Function, udf, uda, Aggregator, expr_udf
-from .type_system import \
-    ColumnType, StringType, IntType, FloatType, BoolType, TimestampType, JsonType, ArrayType, ImageType, VideoType, \
-    AudioType, DocumentType
+from .globals import *
+from .type_system import (
+    ColumnType,
+    StringType,
+    IntType,
+    FloatType,
+    BoolType,
+    TimestampType,
+    JsonType,
+    ArrayType,
+    ImageType,
+    VideoType,
+    AudioType,
+    DocumentType,
+)
 from .utils.help import help
+
 # noinspection PyUnresolvedReferences
-from . import functions
+from . import functions, io
+from .__version__ import __version__, __version_tuple__
 
 __all__ = [
-    'Client',
     'DataFrame',
     'Column',
     'Table',
@@ -39,6 +51,3 @@ __all__ = [
     'uda',
     'expr_udf',
 ]
-
-
-

pixeltable/__version__.py

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

pixeltable/catalog/column.py

@@ -5,8 +5,8 @@ from typing import Optional, Union, Callable, Set
 
 import sqlalchemy as sql
 
-from pixeltable import exceptions as excs
-from pixeltable.type_system import ColumnType, StringType
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
 from .globals import is_valid_identifier
 
 _logger = logging.getLogger('pixeltable')
@@ -18,7 +18,7 @@ class Column:
     table/view.
     """
     def __init__(
-            self, name: Optional[str], col_type: Optional[ColumnType] = None,
+            self, name: Optional[str], col_type: Optional[ts.ColumnType] = None,
             computed_with: Optional[Union['Expr', Callable]] = None,
             is_pk: bool = False, stored: Optional[bool] = None,
             col_id: Optional[int] = None, schema_version_add: Optional[int] = None,
@@ -114,6 +114,10 @@ class Column:
         l = list(self.value_expr.subexprs(filter=lambda e: isinstance(e, exprs.FunctionCall) and e.is_window_fn_call))
         return len(l) > 0
 
+    def get_idx_info(self) -> dict[str, 'pixeltable.catalog.TableVersion.IndexInfo']:
+        assert self.tbl is not None
+        return {name: info for name, info in self.tbl.idxs_by_name.items() if info.col == self}
+
     @property
     def is_computed(self) -> bool:
         return self.compute_func is not None or self.value_expr is not None
@@ -148,8 +152,8 @@ class Column:
             self.store_name(), self.col_type.to_sa_type() if self.sa_col_type is None else self.sa_col_type,
             nullable=True)
         if self.is_computed or self.col_type.is_media_type():
-            self.sa_errormsg_col = sql.Column(self.errormsg_store_name(), StringType().to_sa_type(), nullable=True)
-            self.sa_errortype_col = sql.Column(self.errortype_store_name(), StringType().to_sa_type(), nullable=True)
+            self.sa_errormsg_col = sql.Column(self.errormsg_store_name(), ts.StringType().to_sa_type(), nullable=True)
+            self.sa_errortype_col = sql.Column(self.errortype_store_name(), ts.StringType().to_sa_type(), nullable=True)
 
     def get_sa_col_type(self) -> sql.sqltypes.TypeEngine:
         return self.col_type.to_sa_type() if self.sa_col_type is None else self.sa_col_type

pixeltable/catalog/insertable_table.py

@@ -185,8 +185,6 @@ class InsertableTable(Table):
             if not isinstance(where, Predicate):
                 raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
             analysis_info = Planner.analyze(self.tbl_version_path, where)
-            if analysis_info.similarity_clause is not None:
-                raise excs.Error('nearest() cannot be used with delete()')
             # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
             if analysis_info.filter is not None:
                 raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')

pixeltable/catalog/table.py

@@ -97,6 +97,11 @@ class Table(SchemaObject):
         from pixeltable.dataframe import DataFrame
         return DataFrame(self.tbl_version_path).order_by(*items, asc=asc)
 
+    def group_by(self, *items: 'exprs.Expr') -> 'pixeltable.dataframe.DataFrame':
+        """Return a DataFrame for this table."""
+        from pixeltable.dataframe import DataFrame
+        return DataFrame(self.tbl_version_path).group_by(*items)
+
     def collect(self) -> 'pixeltable.dataframe.DataFrameResultSet':  # type: ignore[name-defined, no-untyped-def]
         """Return rows from this table.
         """
@@ -470,13 +475,16 @@ class Table(SchemaObject):
 
     def add_embedding_index(
             self, col_name: str, *, idx_name: Optional[str] = None,
-            text_embed: Optional[pixeltable.Function] = None, img_embed: Optional[pixeltable.Function] = None
+            text_embed: Optional[pixeltable.Function] = None, img_embed: Optional[pixeltable.Function] = None,
+            metric: str = 'cosine'
     ) -> None:
         """Add an index to the table.
         Args:
             col_name: name of column to index
             idx_name: name of index, which needs to be unique for the table; if not provided, a name will be generated
-            idx_type: type of index (one of 'embedding')
+            text_embed: function to embed text; required if the column is a text column
+            img_embed: function to embed images; required if the column is an image column
+            metric: distance metric to use for the index; one of 'cosine', 'ip', 'l2'; default is 'cosine'
 
         Raises:
             Error: If an index with that name already exists for the table or if the column does not exist.
@@ -484,11 +492,13 @@ class Table(SchemaObject):
         Examples:
             Add an index to the ``img`` column:
 
-            >>> tbl.add_embedding_index('img', text_embed=...)
+            >>> tbl.add_embedding_index('img', img_embed=...)
 
-            Add another index to the ``img`` column, with a specific name:
+            Add another index to the ``img`` column, using the inner product as the distance metric,
+            and with a specific name; ``text_embed`` is also specified in order to search with text:
 
-            >>> tbl.add_embedding_index('img', idx_name='clip_idx', text_embed=...)
+            >>> tbl.add_embedding_index(
+                'img', idx_name='clip_idx', img_embed=..., text_embed=...text_embed..., metric='ip')
         """
         if self.tbl_version_path.is_snapshot():
             raise excs.Error('Cannot add an index to a snapshot')
@@ -500,7 +510,7 @@ class Table(SchemaObject):
             raise excs.Error(f'Duplicate index name: {idx_name}')
         from pixeltable.index import EmbeddingIndex
         # create the EmbeddingIndex instance to verify args
-        idx = EmbeddingIndex(col, text_embed=text_embed, img_embed=img_embed)
+        idx = EmbeddingIndex(col, metric=metric, text_embed=text_embed, img_embed=img_embed)
         status = self.tbl_version_path.tbl_version.add_index(col, idx_name=idx_name, idx=idx)
         # TODO: how to deal with exceptions here? drop the index and raise?
 
@@ -582,8 +592,6 @@ class Table(SchemaObject):
             if not isinstance(where, exprs.Predicate):
                 raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
             analysis_info = Planner.analyze(self.tbl_version_path, where)
-            if analysis_info.similarity_clause is not None:
-                raise excs.Error('nearest() cannot be used with update()')
             # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
             if analysis_info.filter is not None:
                 raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')

pixeltable/catalog/table_version.py

@@ -43,6 +43,7 @@ class TableVersion:
     @dataclasses.dataclass
     class IndexInfo:
         id: int
+        name: str
         idx: index.IndexBase
         col: Column
         val_col: Column
@@ -272,7 +273,7 @@ class TableVersion:
             val_col.sa_col_type = idx.index_sa_type()
             undo_col = self.cols_by_id[md.index_val_undo_col_id]
             undo_col.sa_col_type = idx.index_sa_type()
-            idx_info = self.IndexInfo(id=md.id, idx=idx, col=idx_col, val_col=val_col, undo_col=undo_col)
+            idx_info = self.IndexInfo(id=md.id, name=md.name, idx=idx, col=idx_col, val_col=val_col, undo_col=undo_col)
             self.idxs_by_name[md.name] = idx_info
 
     def _init_sa_schema(self) -> None:
@@ -353,7 +354,7 @@ class TableVersion:
                 indexed_col_id=col.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, idx=idx, col=col, val_col=val_col, undo_col=undo_col)
+            idx_info = self.IndexInfo(id=idx_id, name=idx_name, idx=idx, col=col, val_col=val_col, undo_col=undo_col)
             self.idx_md[idx_id] = idx_md
             self.idxs_by_name[idx_name] = idx_info