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

pixeltable/exprs/rowid_ref.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple
-from .sql_element_cache import SqlElementCache
+
+from typing import Any, Optional
 from uuid import UUID
 
 import sqlalchemy as sql
 
-from .expr import Expr
+import pixeltable.catalog as catalog
+import pixeltable.type_system as ts
+
 from .data_row import DataRow
+from .expr import Expr
 from .row_builder import RowBuilder
-import pixeltable.type_system as ts
-import pixeltable.catalog as catalog
+from .sql_element_cache import SqlElementCache
 
 
 class RowidRef(Expr):
@@ -49,14 +51,14 @@ class RowidRef(Expr):
         return self.normalized_base_id == other.normalized_base_id \
             and self.rowid_component_idx == other.rowid_component_idx
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() +\
             [('normalized_base_id', self.normalized_base_id), ('idx', self.rowid_component_idx)]
 
     def __str__(self) -> str:
         # check if this is the pos column of a component view
         tbl = self.tbl if self.tbl is not None else catalog.Catalog.get().tbl_versions[(self.tbl_id, None)]
-        if tbl.is_component_view() and self.rowid_component_idx == tbl.store_tbl.pos_col_idx:
+        if tbl.is_component_view() and self.rowid_component_idx == tbl.store_tbl.pos_col_idx:  # type: ignore[attr-defined]
             return catalog.globals._POS_COLUMN_NAME
         return ''
 
@@ -68,12 +70,12 @@ class RowidRef(Expr):
         """
         if self.tbl_id == tbl.tbl_version.id:
             return
-        tbl_version_ids = [tbl_version.id for tbl_version in tbl.get_tbl_versions()]
-        assert self.tbl_id in tbl_version_ids
+        base_ids = [tbl_version.id for tbl_version in tbl.get_tbl_versions()]
+        assert self.tbl_id in base_ids  # our current TableVersion is a base of the new TableVersion
         self.tbl = tbl.tbl_version
         self.tbl_id = self.tbl.id
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         tbl = self.tbl if self.tbl is not None else catalog.Catalog.get().tbl_versions[(self.tbl_id, None)]
         rowid_cols = tbl.store_tbl.rowid_columns()
         return rowid_cols[self.rowid_component_idx]
@@ -81,7 +83,7 @@ class RowidRef(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         data_row[self.slot_idx] = data_row.pk[self.rowid_component_idx]
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {
             'tbl_id': str(self.tbl_id),
             'normalized_base_id': str(self.normalized_base_id),
@@ -89,7 +91,6 @@ class RowidRef(Expr):
         }
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> RowidRef:
         tbl_id, normalized_base_id, idx = UUID(d['tbl_id']), UUID(d['normalized_base_id']), d['idx']
         return cls(tbl=None, idx=idx, tbl_id=tbl_id, normalized_base_id=normalized_base_id)
-

pixeltable/exprs/similarity_expr.py

@@ -1,16 +1,16 @@
-from typing import Optional, List, Any
-from .sql_element_cache import SqlElementCache
+from typing import Any, Optional
 
 import sqlalchemy as sql
-import PIL.Image
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+
 from .column_ref import ColumnRef
 from .data_row import DataRow
 from .expr import Expr
 from .literal import Literal
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 
 
 class SimilarityExpr(Expr):
@@ -27,7 +27,7 @@ class SimilarityExpr(Expr):
 
         # determine index to use
         idx_info = col_ref.col.get_idx_info()
-        import pixeltable.index as index
+        from pixeltable import index
         embedding_idx_info = {
             info.name: info for info in idx_info.values() if isinstance(info.idx, index.EmbeddingIndex)
         }
@@ -44,6 +44,7 @@ class SimilarityExpr(Expr):
         else:
             self.idx_info = next(iter(embedding_idx_info.values()))
         idx = self.idx_info.idx
+        assert isinstance(idx, index.EmbeddingIndex)
 
         if item_expr.col_type.is_string_type() and idx.string_embed is None:
             raise excs.Error(
@@ -57,16 +58,20 @@ class SimilarityExpr(Expr):
     def __str__(self) -> str:
         return f'{self.components[0]}.similarity({self.components[1]})'
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    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')
         item = self.components[1].val
+        from pixeltable import index
+        assert isinstance(self.idx_info.idx, index.EmbeddingIndex)
         return self.idx_info.idx.similarity_clause(self.idx_info.val_col, item)
 
-    def as_order_by_clause(self, is_asc: bool) -> Optional[sql.ClauseElement]:
+    def as_order_by_clause(self, is_asc: bool) -> 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')
         item = self.components[1].val
+        from pixeltable import index
+        assert isinstance(self.idx_info.idx, index.EmbeddingIndex)
         return self.idx_info.idx.order_by_clause(self.idx_info.val_col, item, is_asc)
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
@@ -74,7 +79,7 @@ class SimilarityExpr(Expr):
         assert False
 
     @classmethod
-    def _from_dict(cls, d: dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> 'SimilarityExpr':
         assert len(components) == 2
         assert isinstance(components[0], ColumnRef)
         return cls(components[0], components[1])

pixeltable/exprs/sql_element_cache.py

@@ -1,8 +1,9 @@
-from typing import Iterable, Union, Optional
+from typing import Iterable, Union, Optional, cast
 
 import sqlalchemy as sql
 
 from .expr import Expr
+from .expr_dict import ExprDict
 
 
 class SqlElementCache:
@@ -10,8 +11,11 @@ class SqlElementCache:
 
     cache: dict[int, Optional[sql.ColumnElement]]  # key: Expr.id
 
-    def __init__(self):
+    def __init__(self, elements: Optional[ExprDict[sql.ColumnElement]] = None):
         self.cache = {}
+        if elements is not None:
+            for e, el in elements.items():
+                self.cache[e.id] = el
 
     def get(self, e: Expr) -> Optional[sql.ColumnElement]:
         """Returns the sql.ColumnElement for the given Expr, or None if Expr.to_sql() returns None."""
@@ -23,8 +27,10 @@ class SqlElementCache:
         self.cache[e.id] = el
         return el
 
-    def contains(self, items: Union[Expr, Iterable[Expr]]) -> bool:
-        """Returns True if every item has a (non-None) sql.ColumnElement."""
-        if isinstance(items, Expr):
-            return self.get(items) is not None
+    def contains(self, item: Expr) -> bool:
+        """Returns True if the cache contains a (non-None) value for the given Expr."""
+        return self.get(item) is not None
+
+    def contains_all(self, items: Iterable[Expr]) -> bool:
+        """Returns True if the cache contains a (non-None) value for every item in the collection of Exprs."""
         return all(self.get(e) is not None for e in items)

pixeltable/exprs/type_cast.py

@@ -1,8 +1,9 @@
-from typing import Optional, Dict, List, Tuple, Any
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
 import pixeltable.type_system as ts
+
 from .expr import DataRow, Expr
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
@@ -15,7 +16,7 @@ class TypeCast(Expr):
     """
     def __init__(self, underlying: Expr, new_type: ts.ColumnType):
         super().__init__(new_type)
-        self.components: List[Expr] = [underlying]
+        self.components: list[Expr] = [underlying]
         self.id: Optional[int] = self._create_id()
 
     @property
@@ -26,10 +27,10 @@ class TypeCast(Expr):
         # `TypeCast` has no properties beyond those captured by `Expr`.
         return True
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('new_type', self.col_type)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ClauseElement]:
+    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         """
         sql_expr() is unimplemented for now, in order to sidestep potentially thorny
         questions about consistency of doing type conversions in both Python and Postgres.
@@ -40,11 +41,12 @@ class TypeCast(Expr):
         original_val = data_row[self._underlying.slot_idx]
         data_row[self.slot_idx] = self.col_type.create_literal(original_val)
 
-    def _as_dict(self) -> Dict:
+
+    def _as_dict(self) -> dict:
         return {'new_type': self.col_type.as_dict(), **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> 'TypeCast':
         assert 'new_type' in d
         assert len(components) == 1
         return cls(components[0], ts.ColumnType.from_dict(d['new_type']))

pixeltable/exprs/variable.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import List, Tuple, Any, Dict, NoReturn
+from typing import Any, NoReturn
 
 import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
@@ -20,7 +21,7 @@ class Variable(Expr):
         self.name = name
         self.id = self._create_id()
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('name', self.name)]
 
     def default_column_name(self) -> NoReturn:
@@ -38,9 +39,9 @@ class Variable(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> NoReturn:
         raise NotImplementedError()
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'name': self.name, 'type': self.col_type.as_dict(), **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, _: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, _: list[Expr]) -> Variable:
         return cls(d['name'], ts.ColumnType.from_dict(d['type']))

pixeltable/ext/functions/whisperx.py

@@ -8,9 +8,14 @@ if TYPE_CHECKING:
 import pixeltable as pxt
 
 
-@pxt.udf(param_types=[pxt.AudioType(), pxt.StringType(), pxt.StringType(), pxt.StringType(), pxt.IntType()])
+@pxt.udf
 def transcribe(
-    audio: str, *, model: str, compute_type: Optional[str] = None, language: Optional[str] = None, chunk_size: int = 30
+    audio: pxt.Audio,
+    *,
+    model: str,
+    compute_type: Optional[str] = None,
+    language: Optional[str] = None,
+    chunk_size: int = 30
 ) -> dict:
     """
     Transcribe an audio file using WhisperX.

pixeltable/func/aggregate_function.py

@@ -86,7 +86,7 @@ class AggregateFunction(Function):
         res += '\n\n' + inspect.getdoc(self.agg_cls.update)
         return res
 
-    def __call__(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.Expr':
+    def __call__(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.FunctionCall':
         from pixeltable import exprs
 
         # perform semantic analysis of special parameters 'order_by' and 'group_by'

pixeltable/func/callable_function.py

@@ -4,7 +4,7 @@ import inspect
 from typing import Any, Callable, Optional
 from uuid import UUID
 
-import cloudpickle
+import cloudpickle  # type: ignore[import-untyped]
 
 from .function import Function
 from .signature import Signature
@@ -108,7 +108,7 @@ class CallableFunction(Function):
     @classmethod
     def from_store(cls, name: Optional[str], md: dict, binary_obj: bytes) -> Function:
         py_fn = cloudpickle.loads(binary_obj)
-        assert isinstance(py_fn, Callable)
+        assert callable(py_fn)
         sig = Signature.from_dict(md['signature'])
         batch_size = md['batch_size']
         return CallableFunction(sig, py_fn, self_name=name, batch_size=batch_size)

pixeltable/func/function.py

@@ -3,12 +3,13 @@ from __future__ import annotations
 import abc
 import importlib
 import inspect
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Any, Callable, Optional
 
 import sqlalchemy as sql
 
-import pixeltable
+import pixeltable as pxt
 import pixeltable.type_system as ts
+
 from .globals import resolve_symbol
 from .signature import Signature
 
@@ -66,13 +67,13 @@ class Function(abc.ABC):
     def help_str(self) -> str:
         return self.display_name + str(self.signature)
 
-    def __call__(self, *args: Any, **kwargs: Any) -> 'pixeltable.exprs.Expr':
+    def __call__(self, *args: Any, **kwargs: Any) -> 'pxt.exprs.FunctionCall':
         from pixeltable import exprs
         bound_args = self.signature.py_signature.bind(*args, **kwargs)
         self.validate_call(bound_args.arguments)
         return exprs.FunctionCall(self, bound_args.arguments)
 
-    def validate_call(self, bound_args: Dict[str, Any]) -> None:
+    def validate_call(self, bound_args: dict[str, Any]) -> None:
         """Override this to do custom validation of the arguments"""
         pass
 
@@ -121,7 +122,7 @@ class Function(abc.ABC):
         """Print source code"""
         print('source not available')
 
-    def as_dict(self) -> Dict:
+    def as_dict(self) -> dict:
         """
         Return a serialized reference to the instance that can be passed to json.dumps() and converted back
         to an instance with from_dict().
@@ -130,13 +131,13 @@ class Function(abc.ABC):
         classpath = f'{self.__class__.__module__}.{self.__class__.__qualname__}'
         return {'_classpath': classpath, **self._as_dict()}
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         """Default serialization: store the path to self (which includes the module path)"""
         assert self.self_path is not None
         return {'path': self.self_path}
 
     @classmethod
-    def from_dict(cls, d: Dict) -> Function:
+    def from_dict(cls, d: dict) -> Function:
         """
         Turn dict that was produced by calling as_dict() into an instance of the correct Function subclass.
         """
@@ -147,14 +148,14 @@ class Function(abc.ABC):
         return func_class._from_dict(d)
 
     @classmethod
-    def _from_dict(cls, d: Dict) -> Function:
+    def _from_dict(cls, d: dict) -> Function:
         """Default deserialization: load the symbol indicated by the stored symbol_path"""
         assert 'path' in d and d['path'] is not None
         instance = resolve_symbol(d['path'])
         assert isinstance(instance, Function)
         return instance
 
-    def to_store(self) -> Tuple[Dict, bytes]:
+    def to_store(self) -> tuple[dict, bytes]:
         """
         Serialize the function to a format that can be stored in the Pixeltable store
         Returns:
@@ -165,7 +166,7 @@ class Function(abc.ABC):
         raise NotImplementedError()
 
     @classmethod
-    def from_store(cls, name: Optional[str], md: Dict, binary_obj: bytes) -> Function:
+    def from_store(cls, name: Optional[str], md: dict, binary_obj: bytes) -> Function:
         """
         Create a Function instance from the serialized representation returned by to_store()
         """

pixeltable/func/function_registry.py

@@ -4,7 +4,7 @@ import dataclasses
 import importlib
 import logging
 import sys
-from typing import Optional, Dict, List
+from typing import Optional
 from uuid import UUID
 
 import sqlalchemy as sql
@@ -14,7 +14,6 @@ import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
 from pixeltable.metadata import schema
 from .function import Function
-from .globals import get_caller_module_path
 
 _logger = logging.getLogger('pixeltable')
 
@@ -32,15 +31,15 @@ class FunctionRegistry:
         return cls._instance
 
     def __init__(self):
-        self.stored_fns_by_id: Dict[UUID, Function] = {}
-        self.module_fns: Dict[str, Function] = {}  # fqn -> Function
+        self.stored_fns_by_id: dict[UUID, Function] = {}
+        self.module_fns: dict[str, Function] = {}  # fqn -> Function
         self.type_methods: dict[ts.ColumnType.Type, dict[str, Function]] = {}
 
     def clear_cache(self) -> None:
         """
         Useful during testing
         """
-        self.stored_fns_by_id: Dict[UUID, Function] = {}
+        self.stored_fns_by_id = {}
 
     # def register_std_modules(self) -> None:
     #     """Register all submodules of pixeltable.functions"""
@@ -76,7 +75,7 @@ class FunctionRegistry:
                 raise excs.Error(f'Duplicate method name for type {base_type}: {fn.name}')
             self.type_methods[base_type][fn.name] = fn
 
-    def list_functions(self) -> List[Function]:
+    def list_functions(self) -> list[Function]:
         # retrieve Function.Metadata data for all existing stored functions from store directly
         # (self.stored_fns_by_id isn't guaranteed to contain all functions)
         # TODO: have the client do this, once the client takes over the Db functionality
@@ -85,7 +84,7 @@ class FunctionRegistry:
         #         schema.Db.name, schema.Dir.path, sql_func.length(schema.Function.init_obj))\
         #     .where(schema.Function.db_id == schema.Db.id)\
         #     .where(schema.Function.dir_id == schema.Dir.id)
-        # stored_fn_md: List[Function.Metadata] = []
+        # stored_fn_md: list[Function.Metadata] = []
         # with Env.get().engine.begin() as conn:
         #     rows = conn.execute(stmt)
         #     for name, md_dict, db_name, dir_path, init_obj_len in rows:

pixeltable/func/query_template_function.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
+
 import inspect
-from typing import Dict, Optional, Any, Callable
+from typing import Any, Callable, Optional
 
 import sqlalchemy as sql
 
-import pixeltable
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
+import pixeltable as pxt
+from pixeltable import exprs
+
 from .function import Function
-from .signature import Signature, Parameter
+from .signature import Signature
 
 
 class QueryTemplateFunction(Function):
@@ -16,24 +17,23 @@ class QueryTemplateFunction(Function):
 
     @classmethod
     def create(
-            cls, template_callable: Callable, param_types: Optional[list[ts.ColumnType]], path: str, name: str
+        cls, template_callable: Callable, param_types: Optional[list[pxt.ColumnType]], path: str, name: str
     ) -> QueryTemplateFunction:
         # we need to construct a template df and a signature
         py_sig = inspect.signature(template_callable)
         py_params = list(py_sig.parameters.values())
         params = Signature.create_parameters(py_params=py_params, param_types=param_types)
         # invoke template_callable with parameter expressions to construct a DataFrame with parameters
-        import pixeltable.exprs as exprs
         var_exprs = [exprs.Variable(param.name, param.col_type) for param in params]
         template_df = template_callable(*var_exprs)
         from pixeltable import DataFrame
         assert isinstance(template_df, DataFrame)
         # we take params and return json
-        sig = Signature(return_type=ts.JsonType(), parameters=params)
+        sig = Signature(return_type=pxt.JsonType(), parameters=params)
         return QueryTemplateFunction(template_df, sig, path=path, name=name)
 
     def __init__(
-            self, template_df: Optional['pixeltable.DataFrame'], sig: Optional[Signature], path: Optional[str] = None,
+            self, template_df: Optional['pxt.DataFrame'], sig: Optional[Signature], path: Optional[str] = None,
             name: Optional[str] = None,
     ):
         super().__init__(sig, self_path=path)
@@ -46,7 +46,6 @@ class QueryTemplateFunction(Function):
         self.conn: Optional[sql.engine.Connection] = None
 
         # convert defaults to Literals
-        import pixeltable.exprs as exprs
         self.defaults: dict[str, exprs.Literal] = {}  # key: param name, value: default value converted to a Literal
         param_types = self.template_df.parameters()
         for param in [p for p in self.signature.parameters.values() if p.has_default()]:
@@ -75,10 +74,10 @@ class QueryTemplateFunction(Function):
     def name(self) -> str:
         return self.self_name
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'name': self.name, 'signature': self.signature.as_dict(), 'df': self.template_df.as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict) -> Function:
+    def _from_dict(cls, d: dict) -> Function:
         from pixeltable.dataframe import DataFrame
         return cls(DataFrame.from_dict(d['df']), Signature.from_dict(d['signature']), name=d['name'])

pixeltable/func/signature.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-import json
 import dataclasses
 import enum
 import inspect
+import json
 import logging
 import typing
-from typing import Optional, Callable, Dict, List, Any, Union, Tuple
+from typing import Any, Callable, Optional, Union
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -18,7 +18,7 @@ _logger = logging.getLogger('pixeltable')
 class Parameter:
     name: str
     col_type: Optional[ts.ColumnType]  # None for variable parameters
-    kind: enum.Enum  # inspect.Parameter.kind; inspect._ParameterKind is private
+    kind: inspect._ParameterKind
     # for some reason, this needs to precede is_batched in the dataclass definition,
     # otherwise Python complains that an argument with a default is followed by an argument without a default
     default: Any = inspect.Parameter.empty  # default value for the parameter
@@ -82,7 +82,7 @@ class Signature:
     """
     SPECIAL_PARAM_NAMES = ['group_by', 'order_by']
 
-    def __init__(self, return_type: ts.ColumnType, parameters: List[Parameter], is_batched: bool = False):
+    def __init__(self, return_type: ts.ColumnType, parameters: list[Parameter], is_batched: bool = False):
         assert isinstance(return_type, ts.ColumnType)
         self.return_type = return_type
         self.is_batched = is_batched
@@ -97,7 +97,7 @@ class Signature:
         assert isinstance(self.return_type, ts.ColumnType)
         return self.return_type
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         result = {
             'return_type': self.get_return_type().as_dict(),
             'parameters': [p.as_dict() for p in self.parameters.values()],
@@ -106,11 +106,13 @@ class Signature:
         return result
 
     @classmethod
-    def from_dict(cls, d: Dict[str, Any]) -> Signature:
+    def from_dict(cls, d: dict[str, Any]) -> Signature:
         parameters = [Parameter.from_dict(param_dict) for param_dict in d['parameters']]
         return cls(ts.ColumnType.from_dict(d['return_type']), parameters, d['is_batched'])
 
-    def __eq__(self, other: Signature) -> bool:
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Signature):
+            return False
         if self.get_return_type() != other.get_return_type():
             return False
         if len(self.parameters) != len(other.parameters):
@@ -122,7 +124,7 @@ class Signature:
         return True
 
     def __str__(self) -> str:
-        param_strs: List[str] = []
+        param_strs: list[str] = []
         for p in self.parameters.values():
             if p.kind == inspect.Parameter.VAR_POSITIONAL:
                 param_strs.append(f'*{p.name}')
@@ -133,7 +135,7 @@ class Signature:
         return f'({", ".join(param_strs)}) -> {str(self.get_return_type())}'
 
     @classmethod
-    def _infer_type(cls, annotation: Optional[type]) -> Tuple[Optional[ts.ColumnType], Optional[bool]]:
+    def _infer_type(cls, annotation: Optional[type]) -> tuple[Optional[ts.ColumnType], Optional[bool]]:
         """Returns: (column type, is_batched) or (None, ...) if the type cannot be inferred"""
         if annotation is None:
             return (None, None)
@@ -154,13 +156,13 @@ class Signature:
     @classmethod
     def create_parameters(
             cls, py_fn: Optional[Callable] = None, py_params: Optional[list[inspect.Parameter]] = None,
-            param_types: Optional[List[ts.ColumnType]] = None
-    ) -> List[Parameter]:
+            param_types: Optional[list[ts.ColumnType]] = None
+    ) -> list[Parameter]:
         assert (py_fn is None) != (py_params is None)
         if py_fn is not None:
             sig = inspect.signature(py_fn)
             py_params = list(sig.parameters.values())
-        parameters: List[Parameter] = []
+        parameters: list[Parameter] = []
 
         for idx, param in enumerate(py_params):
             if param.name in cls.SPECIAL_PARAM_NAMES:
@@ -187,9 +189,9 @@ class Signature:
 
     @classmethod
     def create(
-            cls, py_fn: Callable,
-            param_types: Optional[List[ts.ColumnType]] = None,
-            return_type: Optional[Union[ts.ColumnType, Callable]] = None
+        cls, py_fn: Callable,
+        param_types: Optional[list[ts.ColumnType]] = None,
+        return_type: Optional[ts.ColumnType] = None
     ) -> Signature:
         """Create a signature for the given Callable.
         Infer the parameter and return types, if none are specified.

pixeltable/func/udf.py

@@ -38,10 +38,6 @@ def udf(*args, **kwargs):
         >>> @pxt.udf
         ... def my_function(x: int) -> int:
         ...    return x + 1
-
-        >>> @pxt.udf(param_types=[pxt.IntType()], return_type=pxt.IntType())
-        ... def my_function(x):
-        ...    return x + 1
     """
     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
 

pixeltable/functions/__init__.py

@@ -1,7 +1,7 @@
 from pixeltable.utils.code import local_public_names
 
-from . import (anthropic, audio, fireworks, huggingface, image, json, mistralai, openai, string, timestamp, together,
-               video, vision)
+from . import (anthropic, audio, fireworks, huggingface, image, json, llama_cpp, mistralai, ollama, openai, string,
+               timestamp, together, video, vision, whisper)
 from .globals import *
 
 __all__ = local_public_names(__name__, exclude=['globals']) + local_public_names(globals.__name__)

pixeltable/functions/audio.py

@@ -11,18 +11,16 @@ t.select(pxtf.audio.get_metadata()).collect()
 ```
 """
 
-import pixeltable.func as func
-import pixeltable.type_system as ts
+import pixeltable as pxt
 from pixeltable.utils.code import local_public_names
 
 
-@func.udf(return_type=ts.JsonType(nullable=False), param_types=[ts.AudioType(nullable=False)], is_method=True)
-def get_metadata(audio: str) -> dict:
+@pxt.udf(is_method=True)
+def get_metadata(audio: pxt.Audio) -> dict:
     """
     Gets various metadata associated with an audio file and returns it as a dictionary.
     """
-    import pixeltable.functions as pxtf
-    return pxtf.video._get_metadata(audio)
+    return pxt.functions.video._get_metadata(audio)
 
 
 __all__ = local_public_names(__name__)