pixeltable 0.2.20__py3-none-any.whl → 0.2.21__py3-none-any.whl

pixeltable/functions/timestamp.py

@@ -15,12 +15,12 @@ from typing import Optional
 
 import sqlalchemy as sql
 
+import pixeltable as pxt
 from pixeltable.env import Env
-import pixeltable.func as func
 from pixeltable.utils.code import local_public_names
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def year(self: datetime) -> int:
     """
     Between [`MINYEAR`](https://docs.python.org/3/library/datetime.html#datetime.MINYEAR) and
@@ -36,7 +36,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('year', self)
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def month(self: datetime) -> int:
     """
     Between 1 and 12 inclusive.
@@ -51,7 +51,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('month', self)
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def day(self: datetime) -> int:
     """
     Between 1 and the number of days in the given month of the given year.
@@ -66,7 +66,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('day', self)
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def hour(self: datetime) -> int:
     """
     Between 0 and 23 inclusive.
@@ -81,7 +81,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('hour', self)
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def minute(self: datetime) -> int:
     """
     Between 0 and 59 inclusive.
@@ -96,7 +96,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('minute', self)
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def second(self: datetime) -> int:
     """
     Between 0 and 59 inclusive.
@@ -111,7 +111,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('second', self)
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def microsecond(self: datetime) -> int:
     """
     Between 0 and 999999 inclusive.
@@ -126,7 +126,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('microseconds', self) - sql.extract('second', self) * 1000000
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def astimezone(self: datetime, tz: str) -> datetime:
     """
     Convert the datetime to the given time zone.
@@ -139,7 +139,7 @@ def astimezone(self: datetime, tz: str) -> datetime:
     return self.astimezone(tzinfo)
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def weekday(self: datetime) -> int:
     """
     Between 0 (Monday) and 6 (Sunday) inclusive.
@@ -154,7 +154,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('isodow', self) - 1
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def isoweekday(self: datetime) -> int:
     """
     Return the day of the week as an integer, where Monday is 1 and Sunday is 7.
@@ -169,7 +169,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
     return sql.extract('isodow', self)
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def isocalendar(self: datetime) -> dict:
     """
     Return a dictionary with three entries: `'year'`, `'week'`, and `'weekday'`.
@@ -181,7 +181,7 @@ def isocalendar(self: datetime) -> dict:
     return {'year': iso_year, 'week': iso_week, 'weekday': iso_weekday}
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def isoformat(self: datetime, sep: str = 'T', timespec: str = 'auto') -> str:
     """
     Return a string representing the date and time in ISO 8601 format.
@@ -195,7 +195,7 @@ def isoformat(self: datetime, sep: str = 'T', timespec: str = 'auto') -> str:
     return self.isoformat(sep=sep, timespec=timespec)
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def strftime(self: datetime, format: str) -> str:
     """
     Return a string representing the date and time, controlled by an explicit format string.
@@ -208,7 +208,7 @@ def strftime(self: datetime, format: str) -> str:
     return self.strftime(format)
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def make_timestamp(
         year: int, month: int, day: int, hour: int = 0, minute: int = 0, second: int = 0, microsecond: int = 0
 ) -> datetime:
@@ -234,7 +234,7 @@ def _(
         sql.cast(minute, sql.Integer),
         sql.cast(second + microsecond / 1000000.0, sql.Double))
 
-# @func.udf
+# @pxt.udf
 # def date(self: datetime) -> datetime:
 #     """
 #     Return the date part of the datetime.
@@ -245,7 +245,7 @@ def _(
 #     return datetime(d.year, d.month, d.day)
 #
 #
-# @func.udf
+# @pxt.udf
 # def time(self: datetime) -> datetime:
 #     """
 #     Return the time part of the datetime, with microseconds set to 0.
@@ -256,7 +256,7 @@ def _(
 #     return datetime(1, 1, 1, t.hour, t.minute, t.second, t.microsecond)
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def replace(
         self: datetime, year: Optional[int] = None, month: Optional[int] = None, day: Optional[int] = None,
         hour: Optional[int] = None, minute: Optional[int] = None, second: Optional[int] = None,
@@ -271,7 +271,7 @@ def replace(
     return self.replace(**kwargs)
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def toordinal(self: datetime) -> int:
     """
     Return the proleptic Gregorian ordinal of the date, where January 1 of year 1 has ordinal 1.
@@ -281,7 +281,7 @@ def toordinal(self: datetime) -> int:
     return self.toordinal()
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def posix_timestamp(self: datetime) -> float:
     """
     Return POSIX timestamp corresponding to the datetime instance.

pixeltable/functions/together.py

@@ -185,8 +185,8 @@ _embedding_dimensions_cache = {
 }
 
 
-@pxt.udf(batch_size=32, return_type=pxt.ArrayType((None,), dtype=pxt.FloatType()))
-def embeddings(input: Batch[str], *, model: str) -> Batch[np.ndarray]:
+@pxt.udf(batch_size=32)
+def embeddings(input: Batch[str], *, model: str) -> Batch[pxt.Array[(None,), float]]:
     """
     Query an embedding model for a given string of text.
 

pixeltable/functions/video.py

@@ -20,9 +20,8 @@ import av  # type: ignore[import-untyped]
 import numpy as np
 import PIL.Image
 
+import pixeltable as pxt
 import pixeltable.env as env
-import pixeltable.func as func
-import pixeltable.type_system as ts
 from pixeltable.utils.code import local_public_names
 
 _format_defaults = {  # format -> (codec, ext)
@@ -48,14 +47,14 @@ _format_defaults = {  # format -> (codec, ext)
 #         output_container.mux(packet)
 
 
-@func.uda(
-    init_types=[ts.IntType()],
-    update_types=[ts.ImageType()],
-    value_type=ts.VideoType(),
+@pxt.uda(
+    init_types=[pxt.IntType()],
+    update_types=[pxt.ImageType()],
+    value_type=pxt.VideoType(),
     requires_order_by=True,
     allows_window=False,
 )
-class make_video(func.Aggregator):
+class make_video(pxt.Aggregator):
     """
     Aggregator that creates a video from a sequence of images.
     """
@@ -88,18 +87,10 @@ class make_video(func.Aggregator):
         return str(self.out_file)
 
 
-_extract_audio_param_types = [
-    ts.VideoType(nullable=False),
-    ts.IntType(nullable=False),
-    ts.StringType(nullable=False),
-    ts.StringType(nullable=True),
-]
-
-
-@func.udf(return_type=ts.AudioType(nullable=True), param_types=_extract_audio_param_types, is_method=True)
+@pxt.udf(is_method=True)
 def extract_audio(
-    video_path: str, stream_idx: int = 0, format: str = 'wav', codec: Optional[str] = None
-) -> Optional[str]:
+    video_path: pxt.Video, stream_idx: int = 0, format: str = 'wav', codec: Optional[str] = None
+) -> pxt.Audio:
     """
     Extract an audio stream from a video file, save it as a media file and return its path.
 
@@ -128,8 +119,8 @@ def extract_audio(
         return output_filename
 
 
-@func.udf(return_type=ts.JsonType(nullable=False), param_types=[ts.VideoType(nullable=False)], is_method=True)
-def get_metadata(video: str) -> dict:
+@pxt.udf(is_method=True)
+def get_metadata(video: pxt.Video) -> dict:
     """
     Gets various metadata associated with a video file and returns it as a dictionary.
     """

pixeltable/functions/whisper.py

@@ -14,27 +14,9 @@ from pixeltable.env import Env
 if TYPE_CHECKING:
     from whisper import Whisper  # type: ignore[import-untyped]
 
-
-@pxt.udf(
-    param_types=[
-        pxt.AudioType(),
-        pxt.StringType(),
-        pxt.JsonType(nullable=True),
-        pxt.FloatType(nullable=True),
-        pxt.FloatType(nullable=True),
-        pxt.FloatType(nullable=True),
-        pxt.BoolType(),
-        pxt.StringType(nullable=True),
-        pxt.BoolType(),
-        pxt.StringType(),
-        pxt.StringType(),
-        pxt.StringType(),
-        pxt.FloatType(nullable=True),
-        pxt.JsonType(nullable=True),
-    ]
-)
+@pxt.udf
 def transcribe(
-    audio: str,
+    audio: pxt.Audio,
     *,
     model: str,
     temperature: Optional[list[float]] = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0],

pixeltable/globals.py

@@ -54,11 +54,13 @@ def create_table(
     Examples:
         Create a table with an int and a string column:
 
-        >>> table = pxt.create_table('my_table', schema={'col1': IntType(), 'col2': StringType()})
+        >>> tbl = pxt.create_table('my_table', schema={'col1': pxt.Int, 'col2': pxt.String})
 
-        Create a table from a select statement over an existing table `tbl`:
+        Create a table from a select statement over an existing table `orig_table` (this will create a new table
+        containing the exact contents of the query):
 
-        >>> table = pxt.create_table('my_table', tbl.where(tbl.col1 < 10).select(tbl.col2))
+        >>> tbl1 = pxt.get_table('orig_table')
+        ... tbl2 = pxt.create_table('new_table', tbl1.where(tbl1.col1 < 10).select(tbl1.col2))
     """
     path = catalog.Path(path_str)
     Catalog.get().paths.check_is_valid(path, expected=None)
@@ -105,8 +107,7 @@ def create_view(
     path_str: str,
     base: Union[catalog.Table, DataFrame],
     *,
-    schema: Optional[dict[str, Any]] = None,
-    filter: Optional[exprs.Expr] = None,
+    additional_columns: Optional[dict[str, Any]] = None,
     is_snapshot: bool = False,
     iterator: Optional[tuple[type[ComponentIterator], dict[str, Any]]] = None,
     num_retained_versions: int = 10,
@@ -116,11 +117,13 @@ def create_view(
     """Create a view of an existing table object (which itself can be a view or a snapshot or a base table).
 
     Args:
-        path_str: Path to the view.
+        path_str: A name for the view; can be either a simple name such as `my_view`, or a pathname such as
+            `dir1.my_view`.
         base: [`Table`][pixeltable.Table] (i.e., table or view or snapshot) or [`DataFrame`][pixeltable.DataFrame] to
             base the view on.
-        schema: dictionary mapping column names to column types, value expressions, or to column specifications.
-        filter: predicate to filter rows of the base table.
+        additional_columns: If specified, will add these columns to the view once it is created. The format
+            of the `additional_columns` parameter is identical to the format of the `schema_or_df` parameter in
+            [`create_table`][pixeltable.create_table].
         is_snapshot: Whether the view is a snapshot.
         iterator: The iterator to use for this view. If specified, then this view will be a one-to-many view of
             the base table.
@@ -130,36 +133,29 @@ def create_view(
 
     Returns:
         A handle to the [`Table`][pixeltable.Table] representing the newly created view. If the path already
-        exists or is invalid and `ignore_errors=True`, returns `None`.
+            exists or is invalid and `ignore_errors=True`, returns `None`.
 
     Raises:
         Error: if the path already exists or is invalid and `ignore_errors=False`.
 
     Examples:
-        Create a view with an additional int and a string column and a filter:
+        Create a view `my_view` of an existing table `my_table`, filtering on rows where `col1` is greater than 10:
 
-        >>> view = cl.create_view(
-            'my_view', base, schema={'col3': IntType(), 'col4': StringType()}, filter=base.col1 > 10)
+        >>> tbl = pxt.get_table('my_table')
+        ... view = pxt.create_view('my_view', tbl.where(tbl.col1 > 10))
 
-        Create a table snapshot:
+        Create a snapshot of `my_table`:
 
-        >>> snapshot_view = cl.create_view('my_snapshot_view', base, is_snapshot=True)
-
-        Create an immutable view with additional computed columns and a filter:
-
-        >>> snapshot_view = cl.create_view(
-            'my_snapshot', base, schema={'col3': base.col2 + 1}, filter=base.col1 > 10, is_snapshot=True)
+        >>> tbl = pxt.get_table('my_table')
+        ... snapshot_view = pxt.create_view('my_snapshot_view', tbl, is_snapshot=True)
     """
+    where: Optional[exprs.Expr] = None
     if isinstance(base, catalog.Table):
         tbl_version_path = base._tbl_version_path
     elif isinstance(base, DataFrame):
         base._validate_mutable('create_view')
         tbl_version_path = base.tbl
-        if base.where_clause is not None and filter is not None:
-            raise excs.Error(
-                'Cannot specify a `filter` directly if one is already declared in a `DataFrame.where` clause'
-            )
-        filter = base.where_clause
+        where = base.where_clause
     else:
         raise excs.Error('`base` must be an instance of `Table` or `DataFrame`')
     assert isinstance(base, catalog.Table) or isinstance(base, DataFrame)
@@ -173,8 +169,8 @@ def create_view(
             raise e
     dir = Catalog.get().paths[path.parent]
 
-    if schema is None:
-        schema = {}
+    if additional_columns is None:
+        additional_columns = {}
     if iterator is None:
         iterator_class, iterator_args = None, None
     else:
@@ -184,8 +180,8 @@ def create_view(
         dir._id,
         path.name,
         base=tbl_version_path,
-        schema=schema,
-        predicate=filter,
+        additional_columns=additional_columns,
+        predicate=where,
         is_snapshot=is_snapshot,
         iterator_cls=iterator_class,
         iterator_args=iterator_args,
@@ -199,7 +195,7 @@ def create_view(
 
 
 def get_table(path: str) -> catalog.Table:
-    """Get a handle to an existing table or view or snapshot.
+    """Get a handle to an existing table, view, or snapshot.
 
     Args:
         path: Path to the table.
@@ -213,15 +209,15 @@ def get_table(path: str) -> catalog.Table:
     Examples:
         Get handle for a table in the top-level directory:
 
-        >>> table = cl.get_table('my_table')
+        >>> tbl = pxt.get_table('my_table')
 
         For a table in a subdirectory:
 
-        >>> table = cl.get_table('subdir.my_table')
+        >>> tbl = pxt.get_table('subdir.my_table')
 
-        For a snapshot in the top-level directory:
+        Handles to views and snapshots are retrieved in the same way:
 
-        >>> table = cl.get_table('my_snapshot')
+        >>> tbl = pxt.get_table('my_snapshot')
     """
     p = catalog.Path(path)
     Catalog.get().paths.check_is_valid(p, expected=catalog.Table)
@@ -243,11 +239,11 @@ def move(path: str, new_path: str) -> None:
     Examples:
         Move a table to a different directory:
 
-        >>>> cl.move('dir1.my_table', 'dir2.my_table')
+        >>>> pxt.move('dir1.my_table', 'dir2.my_table')
 
         Rename a table:
 
-        >>>> cl.move('dir1.my_table', 'dir1.new_name')
+        >>>> pxt.move('dir1.my_table', 'dir1.new_name')
     """
     p = catalog.Path(path)
     Catalog.get().paths.check_is_valid(p, expected=catalog.SchemaObject)
@@ -260,18 +256,18 @@ def move(path: str, new_path: str) -> None:
 
 
 def drop_table(path: str, force: bool = False, ignore_errors: bool = False) -> None:
-    """Drop a table or view or snapshot.
+    """Drop a table, view, or snapshot.
 
     Args:
         path: Path to the [`Table`][pixeltable.Table].
-        force: If `True`, will also drop all views or sub-views of this table.
-        ignore_errors: Whether to ignore errors if the table does not exist.
+        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 is False.
+        Error: If the path does not exist or does not designate a table object, and `ignore_errors=False`.
 
     Examples:
-        >>> cl.drop_table('my_table')
+        >>> pxt.drop_table('my_table')
     """
     cat = Catalog.get()
     path_obj = catalog.Path(path)
@@ -302,7 +298,8 @@ def list_tables(dir_path: str = '', recursive: bool = True) -> list[str]:
 
     Args:
         dir_path: Path to the directory. Defaults to the root directory.
-        recursive: Whether to list tables in subdirectories as well.
+        recursive: If `False`, returns only those tables that are directly contained in specified directory; if
+            `True`, returns all tables that are descendants of the specified directory, recursively.
 
     Returns:
         A list of [`Table`][pixeltable.Table] paths.
@@ -313,13 +310,11 @@ def list_tables(dir_path: str = '', recursive: bool = True) -> list[str]:
     Examples:
         List tables in top-level directory:
 
-        >>> cl.list_tables()
-        ['my_table', ...]
+        >>> pxt.list_tables()
 
         List tables in 'dir1':
 
-        >>> cl.list_tables('dir1')
-        [...]
+        >>> pxt.list_tables('dir1')
     """
     assert dir_path is not None
     path = catalog.Path(dir_path, empty_is_valid=True)
@@ -332,17 +327,17 @@ def create_dir(path_str: str, ignore_errors: bool = False) -> Optional[catalog.D
 
     Args:
         path_str: Path to the directory.
-        ignore_errors: if True, silently returns on error
+        ignore_errors: if `True`, will return silently instead of throwing an exception if an error occurs.
 
     Raises:
-        Error: If the path already exists or the parent is not a directory.
+        Error: If the path already exists or the parent is not a directory, and `ignore_errors=False`.
 
     Examples:
-        >>> cl.create_dir('my_dir')
+        >>> pxt.create_dir('my_dir')
 
         Create a subdirectory:
 
-        >>> cl.create_dir('my_dir.sub_dir')
+        >>> pxt.create_dir('my_dir.sub_dir')
     """
     try:
         path = catalog.Path(path_str)
@@ -373,17 +368,21 @@ def drop_dir(path_str: str, force: bool = False, ignore_errors: bool = False) ->
     """Remove a directory.
 
     Args:
-        path_str: Path to the directory.
+        path_str: Name or path of the directory.
+        force: If `True`, will also drop all tables and subdirectories of this directory, recursively, along
+            with any views or snapshots that depend on any of the dropped tables.
+        ignore_errors: if `True`, will return silently instead of throwing an exception if the directory
+            does not exist.
 
     Raises:
-        Error: If the path does not exist or does not designate a directory or if the directory is not empty.
+        Error: If the path does not exist or does not designate a directory, or if the directory is not empty.
 
     Examples:
-        >>> cl.drop_dir('my_dir')
+        >>> pxt.drop_dir('my_dir')
 
         Remove a subdirectory:
 
-        >>> cl.drop_dir('my_dir.sub_dir')
+        >>> pxt.drop_dir('my_dir.sub_dir')
     """
     cat = Catalog.get()
     path = catalog.Path(path_str)
@@ -428,14 +427,14 @@ def list_dirs(path_str: str = '', recursive: bool = True) -> list[str]:
     """List the directories in a directory.
 
     Args:
-        path_str: Path to the directory.
-        recursive: Whether to list subdirectories recursively.
+        path_str: Name or path of the directory.
+        recursive: If `True`, lists all descendants of this directory recursively.
 
     Returns:
         List of directory paths.
 
     Raises:
-        Error: If the path does not exist or does not designate a directory.
+        Error: If `path_str` does not exist or does not designate a directory.
 
     Examples:
         >>> cl.list_dirs('my_dir', recursive=True)

pixeltable/index/base.py

@@ -5,7 +5,7 @@ from typing import Any
 
 import sqlalchemy as sql
 
-import pixeltable.catalog as catalog
+from pixeltable import catalog, exprs
 
 
 class IndexBase(abc.ABC):
@@ -22,7 +22,7 @@ class IndexBase(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def index_value_expr(self) -> 'pixeltable.exprs.Expr':
+    def index_value_expr(self) -> exprs.Expr:
         """Return expression that computes the value that goes into the index"""
         pass
 

pixeltable/index/btree.py

@@ -2,10 +2,10 @@ from typing import Optional
 
 import sqlalchemy as sql
 
-# TODO: why does this import result in a circular import, but the one im embedding_index.py doesn't?
-#import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
-import pixeltable.func as func
+from pixeltable import catalog, exprs
+from pixeltable.func.udf import udf
+
 from .base import IndexBase
 
 
@@ -15,7 +15,8 @@ class BtreeIndex(IndexBase):
     """
     MAX_STRING_LEN = 256
 
-    @func.udf
+    @staticmethod
+    @udf
     def str_filter(s: Optional[str]) -> Optional[str]:
         if s is None:
             return None
@@ -24,10 +25,9 @@ class BtreeIndex(IndexBase):
     def __init__(self, c: 'catalog.Column'):
         if not c.col_type.is_scalar_type() and not c.col_type.is_media_type():
             raise excs.Error(f'Index on column {c.name}: B-tree index requires scalar or media type, got {c.col_type}')
-        from pixeltable.exprs import ColumnRef
-        self.value_expr = self.str_filter(ColumnRef(c)) if c.col_type.is_string_type() else ColumnRef(c)
+        self.value_expr = BtreeIndex.str_filter(exprs.ColumnRef(c)) if c.col_type.is_string_type() else exprs.ColumnRef(c)
 
-    def index_value_expr(self) -> 'pixeltable.exprs.Expr':
+    def index_value_expr(self) -> 'exprs.Expr':
         return self.value_expr
 
     def records_value_errors(self) -> bool:

pixeltable/index/embedding_index.py

@@ -1,18 +1,17 @@
 from __future__ import annotations
 
-from typing import Optional, Any
 import enum
+from typing import Any, Optional
 
-import PIL.Image
 import numpy as np
-import pgvector.sqlalchemy
+import pgvector.sqlalchemy  # type: ignore[import-untyped]
 import PIL.Image
 import sqlalchemy as sql
 
-import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
-import pixeltable.func as func
 import pixeltable.type_system as ts
+from pixeltable import catalog, exprs, func
+
 from .base import IndexBase
 
 
@@ -58,16 +57,15 @@ class EmbeddingIndex(IndexBase):
             self._validate_embedding_fn(image_embed, 'image_embed', ts.ColumnType.Type.IMAGE)
 
         self.metric = self.Metric[metric.upper()]
-        from pixeltable.exprs import ColumnRef
-        self.value_expr = string_embed(ColumnRef(c)) if c.col_type.is_string_type() else image_embed(ColumnRef(c))
-        assert self.value_expr.col_type.is_array_type()
+        self.value_expr = string_embed(exprs.ColumnRef(c)) if c.col_type.is_string_type() else image_embed(exprs.ColumnRef(c))
+        assert isinstance(self.value_expr.col_type, ts.ArrayType)
         self.string_embed = string_embed
         self.image_embed = image_embed
         vector_size = self.value_expr.col_type.shape[0]
         assert vector_size is not None
         self.index_col_type = pgvector.sqlalchemy.Vector(vector_size)
 
-    def index_value_expr(self) -> 'pixeltable.exprs.Expr':
+    def index_value_expr(self) -> exprs.Expr:
         """Return expression that computes the value that goes into the index"""
         return self.value_expr
 
@@ -151,7 +149,7 @@ class EmbeddingIndex(IndexBase):
             img = PIL.Image.new('RGB', (512, 512))
             return_type = embed_fn.call_return_type({param_name: img})
         assert return_type is not None
-        if not return_type.is_array_type():
+        if not isinstance(return_type, ts.ArrayType):
             raise excs.Error(f'{name} must return an array, but returns {return_type}')
         else:
             shape = return_type.shape