pixeltable 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

pixeltable/exprs/similarity_expr.py

@@ -62,14 +62,14 @@ class SimilarityExpr(Expr):
         return f'{self.components[0]}.similarity({self.components[1]})'
 
     def _id_attrs(self):
-        return super()._id_attrs() + [('idx_name', self.idx_info.name)]
+        return [*super()._id_attrs(), ('idx_name', self.idx_info.name)]
 
     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')
+            raise excs.Error('similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
         from pixeltable import index
 
@@ -78,7 +78,7 @@ class SimilarityExpr(Expr):
 
     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')
+            raise excs.Error('similarity(): requires a string or a PIL.Image.Image object, not an expression')
         item = self.components[1].val
         from pixeltable import index
 
@@ -87,14 +87,14 @@ class SimilarityExpr(Expr):
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         # this should never get called
-        assert False
+        raise AssertionError()
 
     def _as_dict(self) -> dict:
         return {'idx_name': self.idx_info.name, **super()._as_dict()}
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> 'SimilarityExpr':
-        iname = d['idx_name'] if 'idx_name' in d else None
+        iname = d.get('idx_name')
         assert len(components) == 2
         assert isinstance(components[0], ColumnRef)
         return cls(components[0], components[1], idx_name=iname)

pixeltable/exprs/sql_element_cache.py

@@ -1,4 +1,4 @@
-from typing import Iterable, Optional, Union, cast
+from typing import Iterable, Optional
 
 import sqlalchemy as sql
 

pixeltable/exprs/type_cast.py

@@ -1,9 +1,8 @@
-from typing import Any, Optional, Union
+from typing import Optional
 
 import sqlalchemy as sql
 
-import pixeltable.exprs as exprs
-import pixeltable.type_system as ts
+from pixeltable import type_system as ts
 
 from .expr import DataRow, Expr
 from .literal import Literal

pixeltable/exprs/variable.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any, NoReturn
 
-import pixeltable.type_system as ts
+from pixeltable import type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
@@ -22,7 +22,7 @@ class Variable(Expr):
         self.id = self._create_id()
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('name', self.name)]
+        return [*super()._id_attrs(), ('name', self.name)]
 
     def default_column_name(self) -> NoReturn:
         raise NotImplementedError()

pixeltable/ext/__init__.py

@@ -4,6 +4,8 @@ are not intended for production use. Long-term support cannot be guaranteed, usu
 have dependencies whose future support is unclear.
 """
 
+# ruff: noqa: F401
+
 from pixeltable.utils.code import local_public_names
 
 from . import functions

pixeltable/ext/functions/__init__.py

@@ -1,3 +1,5 @@
+# ruff: noqa: F401
+
 from pixeltable.utils.code import local_public_names
 
 from . import whisperx, yolox

pixeltable/ext/functions/yolox.py

@@ -111,10 +111,10 @@ def _images_to_tensors(images: Iterable[PIL.Image.Image], exp: 'Exp') -> Iterato
     import torch
     from yolox.data import ValTransform  # type: ignore[import-untyped]
 
-    _val_transform = ValTransform(legacy=False)
+    val_transform = ValTransform(legacy=False)
     for image in images:
-        image = normalize_image_mode(image)
-        image_transform, _ = _val_transform(np.array(image), None, exp.test_size)
+        normalized_image = normalize_image_mode(image)
+        image_transform, _ = val_transform(np.array(normalized_image), None, exp.test_size)
         yield torch.from_numpy(image_transform)
 
 

pixeltable/func/__init__.py

@@ -1,7 +1,9 @@
+# ruff: noqa: F401
+
 from .aggregate_function import AggregateFunction, Aggregator, uda
 from .callable_function import CallableFunction
 from .expr_template_function import ExprTemplateFunction
-from .function import Function
+from .function import Function, InvalidFunction
 from .function_registry import FunctionRegistry
 from .query_template_function import QueryTemplateFunction, query
 from .signature import Batch, Parameter, Signature

pixeltable/func/aggregate_function.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import abc
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, overload
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Sequence, overload
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -16,11 +16,11 @@ if TYPE_CHECKING:
 
 
 class Aggregator(abc.ABC):
-    def update(self, *args: Any, **kwargs: Any) -> None:
-        pass
+    @abc.abstractmethod
+    def update(self, *args: Any, **kwargs: Any) -> None: ...
 
-    def value(self) -> Any:
-        pass
+    @abc.abstractmethod
+    def value(self) -> Any: ...
 
 
 class AggregateFunction(Function):
@@ -32,9 +32,9 @@ class AggregateFunction(Function):
     allows_window: if True, the aggregate function can be used with a window
     """
 
-    ORDER_BY_PARAM = 'order_by'
-    GROUP_BY_PARAM = 'group_by'
-    RESERVED_PARAMS = {ORDER_BY_PARAM, GROUP_BY_PARAM}
+    ORDER_BY_PARAM: ClassVar[str] = 'order_by'
+    GROUP_BY_PARAM: ClassVar[str] = 'group_by'
+    RESERVED_PARAMS: ClassVar[set[str]] = {ORDER_BY_PARAM, GROUP_BY_PARAM}
 
     agg_classes: list[type[Aggregator]]  # classes for each signature, in signature order
     init_param_names: list[list[str]]  # names of the __init__ parameters for each signature
@@ -124,7 +124,7 @@ class AggregateFunction(Function):
             )
             for i, p in enumerate(py_init_params)
         ]
-        duplicate_params = set(p.name for p in init_params) & set(p.name for p in update_params)
+        duplicate_params = {p.name for p in init_params} & {p.name for p in update_params}
         if len(duplicate_params) > 0:
             raise excs.Error(
                 f'__init__() and update() cannot have parameters with the same name: {", ".join(duplicate_params)}'

pixeltable/func/callable_function.py

@@ -98,11 +98,10 @@ class CallableFunction(Function):
                 result = self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
             assert len(result) == 1
             return result[0]
+        elif inspect.iscoroutinefunction(self.py_fn):
+            return asyncio.run(self.py_fn(*args, **kwargs))
         else:
-            if inspect.iscoroutinefunction(self.py_fn):
-                return asyncio.run(self.py_fn(*args, **kwargs))
-            else:
-                return self.py_fn(*args, **kwargs)
+            return self.py_fn(*args, **kwargs)
 
     async def aexec_batch(self, *args: Any, **kwargs: Any) -> list:
         """Execute the function with the given arguments and return the result.

pixeltable/func/expr_template_function.py

@@ -1,8 +1,6 @@
-import inspect
 from typing import Any, Optional, Sequence
 
-import pixeltable
-import pixeltable.exceptions as excs
+from pixeltable import exceptions as excs, exprs
 
 from .function import Function
 from .signature import Signature
@@ -15,13 +13,11 @@ class ExprTemplate:
     `CallableFunction`.)
     """
 
-    expr: 'pixeltable.exprs.Expr'
+    expr: 'exprs.Expr'
     signature: Signature
-    param_exprs: dict[str, 'pixeltable.exprs.Variable']
-
-    def __init__(self, expr: 'pixeltable.exprs.Expr', signature: Signature):
-        from pixeltable import exprs
+    param_exprs: dict[str, 'exprs.Variable']
 
+    def __init__(self, expr: 'exprs.Expr', signature: Signature):
         self.expr = expr
         self.signature = signature
 
@@ -59,9 +55,7 @@ class ExprTemplateFunction(Function):
         assert not self.is_polymorphic
         return self.templates[0]
 
-    def instantiate(self, args: Sequence[Any], kwargs: dict[str, Any]) -> 'pixeltable.exprs.Expr':
-        from pixeltable import exprs
-
+    def instantiate(self, args: Sequence[Any], kwargs: dict[str, Any]) -> 'exprs.Expr':
         assert not self.is_polymorphic
         template = self.template
         bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
@@ -86,14 +80,12 @@ class ExprTemplateFunction(Function):
         return result
 
     def _docstring(self) -> Optional[str]:
-        from pixeltable import exprs
-
         if isinstance(self.templates[0].expr, exprs.FunctionCall):
             return self.templates[0].expr.fn._docstring()
         return None
 
     def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
-        from pixeltable import exec, exprs
+        from pixeltable import exec
 
         assert not self.is_polymorphic
         expr = self.instantiate(args, kwargs)
@@ -130,7 +122,5 @@ class ExprTemplateFunction(Function):
         if 'expr' not in d:
             return super()._from_dict(d)
         assert 'signature' in d and 'name' in d
-        import pixeltable.exprs as exprs
-
         template = ExprTemplate(exprs.Expr.from_dict(d['expr']), Signature.from_dict(d['signature']))
         return cls([template], name=d['name'])

pixeltable/func/function.py

@@ -62,7 +62,6 @@ class Function(ABC):
         # Check that stored functions cannot be declared using `is_method` or `is_property`:
         assert not ((is_method or is_property) and self_path is None)
         assert isinstance(signatures, list)
-        assert len(signatures) > 0
         self.signatures = signatures
         self.self_path = self_path  # fully-qualified path to self
         self.is_method = is_method
@@ -72,6 +71,10 @@ class Function(ABC):
         self._to_sql = self.__default_to_sql
         self._resource_pool = self.__default_resource_pool
 
+    @property
+    def is_valid(self) -> bool:
+        return len(self.signatures) > 0
+
     @property
     def name(self) -> str:
         assert self.self_path is not None
@@ -243,7 +246,7 @@ class Function(ABC):
         # `None` when any of its non-nullable inputs are `None`.
         for arg_name, arg in bound_args.items():
             param = self.signature.parameters[arg_name]
-            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}:
                 continue
             if arg.col_type.nullable and not param.col_type.nullable:
                 return_type = return_type.copy(nullable=True)
@@ -301,13 +304,12 @@ class Function(ABC):
                     callable_args[param.name] = arg
                 else:
                     return None
-            else:
+            elif isinstance(arg, exprs.Literal):
                 # The callable is expecting `param.name` to be a constant Python value. Unpack a Literal if we find
                 # one; otherwise return None.
-                if isinstance(arg, exprs.Literal):
-                    callable_args[param.name] = arg.val
-                else:
-                    return None
+                callable_args[param.name] = arg.val
+            else:
+                return None
 
         return callable_args
 
@@ -383,10 +385,10 @@ class Function(ABC):
             else:
                 var = exprs.Variable(name, param.col_type)
                 bindings[name] = var
-                if args_ok and param.kind in (
+                if args_ok and param.kind in {
                     inspect.Parameter.POSITIONAL_ONLY,
                     inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                ):
+                }:
                     template_args.append(var)
                 else:
                     template_kwargs[name] = var
@@ -433,6 +435,9 @@ class Function(ABC):
             return False
         return self.self_path == other.self_path
 
+    def __hash__(self) -> int:
+        return hash(self.self_path)
+
     def source(self) -> None:
         """Print source code"""
         print('source not available')
@@ -468,11 +473,18 @@ class Function(ABC):
     @classmethod
     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
-        assert 'signature' in d and d['signature'] is not None
-        instance = resolve_symbol(d['path'])
-        assert isinstance(instance, Function)
-        return instance
+        path = d.get('path')
+        assert path is not None
+        try:
+            instance = resolve_symbol(path)
+            if isinstance(instance, Function):
+                return instance
+            else:
+                return InvalidFunction(
+                    path, d, f'the symbol {path!r} is no longer a UDF. (Was the `@pxt.udf` decorator removed?)'
+                )
+        except (AttributeError, ImportError):
+            return InvalidFunction(path, d, f'the symbol {path!r} no longer exists. (Was the UDF moved or renamed?)')
 
     def to_store(self) -> tuple[dict, bytes]:
         """
@@ -490,3 +502,25 @@ class Function(ABC):
         Create a Function instance from the serialized representation returned by to_store()
         """
         raise NotImplementedError()
+
+
+class InvalidFunction(Function):
+    fn_dict: dict[str, Any]
+    errormsg: str
+
+    def __init__(self, self_path: str, fn_dict: dict[str, Any], errormsg: str):
+        super().__init__([], self_path)
+        self.fn_dict = fn_dict
+        self.errormsg = errormsg
+
+    def _as_dict(self) -> dict:
+        """
+        Here we write out (verbatim) the original metadata that failed to load (and that resulted in the
+        InvalidFunction). Note that the InvalidFunction itself is never serlialized, so there is no corresponding
+        from_dict() method.
+        """
+        return self.fn_dict
+
+    @property
+    def is_async(self) -> bool:
+        return False

pixeltable/func/function_registry.py

@@ -9,9 +9,7 @@ from uuid import UUID
 
 import sqlalchemy as sql
 
-import pixeltable.env as env
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
+from pixeltable import env, exceptions as excs, type_system as ts
 from pixeltable.metadata import schema
 
 from .function import Function

pixeltable/func/query_template_function.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, overload
+from typing import TYPE_CHECKING, Any, Callable, Optional, overload
 
-import sqlalchemy as sql
-
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
-from pixeltable import exprs
+from pixeltable import exprs, type_system as ts
 
 from .function import Function
 from .signature import Signature
@@ -21,7 +17,7 @@ class QueryTemplateFunction(Function):
 
     template_df: Optional['DataFrame']
     self_name: Optional[str]
-    conn: Optional[sql.engine.Connection]
+    # conn: Optional[sql.engine.Connection]
     defaults: dict[str, exprs.Literal]
 
     @classmethod
@@ -53,7 +49,7 @@ class QueryTemplateFunction(Function):
         # if we're running as part of an ongoing update operation, we need to use the same connection, otherwise
         # we end up with a deadlock
         # TODO: figure out a more general way to make execution state available
-        self.conn = None
+        # self.conn = None
 
         # convert defaults to Literals
         self.defaults = {}  # key: param name, value: default value converted to a Literal
@@ -67,9 +63,6 @@ class QueryTemplateFunction(Function):
     def _update_as_overload_resolution(self, signature_idx: int) -> None:
         pass  # only one signature supported for QueryTemplateFunction
 
-    def set_conn(self, conn: Optional[sql.engine.Connection]) -> None:
-        self.conn = conn
-
     @property
     def is_async(self) -> bool:
         return True
@@ -82,7 +75,7 @@ class QueryTemplateFunction(Function):
             {param_name: default for param_name, default in self.defaults.items() if param_name not in bound_args}
         )
         bound_df = self.template_df.bind(bound_args)
-        result = await bound_df._acollect(self.conn)
+        result = await bound_df._acollect()
         return list(result)
 
     @property

pixeltable/func/signature.py

@@ -2,10 +2,9 @@ from __future__ import annotations
 
 import dataclasses
 import inspect
-import json
 import logging
 import typing
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -69,6 +68,9 @@ class Parameter:
         py_default = self.default.val if self.default is not None else inspect.Parameter.empty
         return inspect.Parameter(self.name, self.kind, default=py_default)
 
+    def __hash__(self) -> int:
+        return hash((self.name, self.col_type, self.kind, self.default, self.is_batched))
+
 
 T = typing.TypeVar('T')
 Batch = typing.Annotated[list[T], 'pxt-batch']
@@ -81,7 +83,7 @@ class Signature:
     - self.is_batched: return type is a Batch[...] type
     """
 
-    SPECIAL_PARAM_NAMES = ['group_by', 'order_by']
+    SPECIAL_PARAM_NAMES: ClassVar[list[str]] = ['group_by', 'order_by']
 
     def __init__(self, return_type: ts.ColumnType, parameters: list[Parameter], is_batched: bool = False):
         assert isinstance(return_type, ts.ColumnType)
@@ -135,26 +137,28 @@ class Signature:
             if (
                 param.kind != other_param.kind
                 or (param.col_type is None) != (other_param.col_type is None)  # this can happen if they are varargs
-                or param.col_type is not None
-                and not other_param.col_type.is_supertype_of(param.col_type, ignore_nullable=True)
+                or (
+                    param.col_type is not None
+                    and not other_param.col_type.is_supertype_of(param.col_type, ignore_nullable=True)
+                )
             ):
                 return False
 
         # Check (iii)
-        for other_param in other.required_parameters:
+        for other_param in other.required_parameters:  # noqa: SIM110
             if other_param.name not in self.parameters:
                 return False
 
         return True
 
     def validate_args(self, bound_args: dict[str, Optional['exprs.Expr']], context: str = '') -> None:
-        if context != '':
+        if context:
             context = f' ({context})'
 
         for param_name, arg in bound_args.items():
             assert param_name in self.parameters
             param = self.parameters[param_name]
-            is_var_param = param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+            is_var_param = param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}
             if is_var_param:
                 continue
             assert param.col_type is not None
@@ -191,6 +195,9 @@ class Signature:
                 return False
         return True
 
+    def __hash__(self) -> int:
+        return hash((self.return_type, self.parameters))
+
     def __str__(self) -> str:
         param_strs: list[str] = []
         for p in self.parameters.values():
@@ -199,8 +206,8 @@ class Signature:
             elif p.kind == inspect.Parameter.VAR_KEYWORD:
                 param_strs.append(f'**{p.name}')
             else:
-                param_strs.append(f'{p.name}: {str(p.col_type)}')
-        return f'({", ".join(param_strs)}) -> {str(self.get_return_type())}'
+                param_strs.append(f'{p.name}: {p.col_type}')
+        return f'({", ".join(param_strs)}) -> {self.get_return_type()}'
 
     @classmethod
     def _infer_type(cls, annotation: Optional[type]) -> tuple[Optional[ts.ColumnType], Optional[bool]]:
@@ -213,7 +220,7 @@ class Signature:
             type_args = typing.get_args(annotation)
             if len(type_args) == 2 and type_args[1] == 'pxt-batch':
                 # this is our Batch
-                assert typing.get_origin(type_args[0]) == list
+                assert typing.get_origin(type_args[0]) is list
                 is_batched = True
                 py_type = typing.get_args(type_args[0])[0]
         if py_type is None:
@@ -246,7 +253,7 @@ class Signature:
                 continue  # skip 'self' or 'cls' parameter
             if param.name in cls.SPECIAL_PARAM_NAMES:
                 raise excs.Error(f'{param.name!r} is a reserved parameter name')
-            if param.kind == inspect.Parameter.VAR_POSITIONAL or param.kind == inspect.Parameter.VAR_KEYWORD:
+            if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}:
                 parameters.append(Parameter(param.name, col_type=None, kind=param.kind))
                 continue
 
@@ -257,11 +264,8 @@ class Signature:
                 param_type = param_types[idx]
                 is_batched = False
             else:
-                py_type: Optional[type]
-                if param.annotation in type_substitutions:
-                    py_type = type_substitutions[param.annotation]
-                else:
-                    py_type = param.annotation
+                # Look up the substitution for param.annotation, defaulting to param.annotation if there is none
+                py_type = type_substitutions.get(param.annotation, param.annotation)
                 param_type, is_batched = cls._infer_type(py_type)
                 if param_type is None:
                     raise excs.Error(f'Cannot infer pixeltable type for parameter {param.name!r}')
@@ -297,11 +301,8 @@ class Signature:
         )
         sig = inspect.signature(py_fn)
         if return_type is None:
-            py_type: Optional[type]
-            if sig.return_annotation in type_substitutions:
-                py_type = type_substitutions[sig.return_annotation]
-            else:
-                py_type = sig.return_annotation
+            # Look up the substitution for sig.return_annotation, defaulting to return_annotation if there is none
+            py_type = type_substitutions.get(sig.return_annotation, sig.return_annotation)
             return_type, return_is_batched = cls._infer_type(py_type)
             if return_type is None:
                 raise excs.Error('Cannot infer pixeltable return type')

pixeltable/func/tools.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
 
 import pydantic
 
@@ -69,7 +69,7 @@ class Tool(pydantic.BaseModel):
             return _extract_float_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_bool_type():
             return _extract_bool_tool_arg(kwargs, param_name=param.name)
-        assert False
+        raise AssertionError()
 
 
 class ToolChoice(pydantic.BaseModel):
@@ -113,7 +113,7 @@ class Tools(pydantic.BaseModel):
                 )
                 tool_name = tool_obj.name or tool_obj.fn.name
             except StopIteration:
-                raise excs.Error(f'That tool is not in the specified list of tools: {tool}')
+                raise excs.Error(f'That tool is not in the specified list of tools: {tool}') from None
         return ToolChoice(auto=auto, required=required, tool=tool_name, parallel_tool_calls=parallel_tool_calls)
 
 

pixeltable/func/udf.py

@@ -146,7 +146,8 @@ def make_function(
             raise excs.Error(f'Cannot specify both `is_method` and `is_property` (in function `{function_name}`)')
         if is_property and len(sig.parameters) != 1:
             raise excs.Error(
-                f'`is_property=True` expects a UDF with exactly 1 parameter, but `{function_name}` has {len(sig.parameters)}'
+                '`is_property=True` expects a UDF with exactly 1 parameter, but '
+                f'`{function_name}` has {len(sig.parameters)}'
             )
         if (is_method or is_property) and function_path is None:
             raise excs.Error('Stored functions cannot be declared using `is_method` or `is_property`')
@@ -205,6 +206,8 @@ def expr_udf(*, param_types: Optional[list[ts.ColumnType]] = None) -> Callable[[
 
 def expr_udf(*args: Any, **kwargs: Any) -> Any:
     def make_expr_template(py_fn: Callable, param_types: Optional[list[ts.ColumnType]]) -> ExprTemplateFunction:
+        from pixeltable import exprs
+
         if py_fn.__module__ != '__main__' and py_fn.__name__.isidentifier():
             # this is a named function in a module
             function_path = f'{py_fn.__module__}.{py_fn.__qualname__}'
@@ -216,7 +219,6 @@ def expr_udf(*args: Any, **kwargs: Any) -> Any:
 
         # construct Signature from the function signature
         sig = Signature.create(py_fn=py_fn, param_types=param_types, return_type=ts.InvalidType())
-        import pixeltable.exprs as exprs
 
         var_exprs = [exprs.Variable(param.name, param.col_type) for param in sig.parameters.values()]
         # call the function with the parameter expressions to construct an Expr with parameters
@@ -260,7 +262,7 @@ def from_table(
     """
     from pixeltable import exprs
 
-    ancestors = [tbl] + tbl._bases
+    ancestors = [tbl, *tbl._bases]
     ancestors.reverse()  # We must traverse the ancestors in order from base to derived
 
     subst: dict[exprs.Expr, exprs.Expr] = {}
@@ -268,7 +270,7 @@ def from_table(
     params: list[Parameter] = []
 
     for t in ancestors:
-        for name, col in t._tbl_version.cols_by_name.items():
+        for name, col in t._tbl_version.get().cols_by_name.items():
             assert name not in result_dict, f'Column name is not unique: {name}'
             if col.is_computed:
                 # Computed column. Apply any existing substitutions and add the new expression to the subst dict.

pixeltable/functions/__init__.py

@@ -1,3 +1,5 @@
+# ruff: noqa: F401
+
 from pixeltable.utils.code import local_public_names
 
 from . import (