pixeltable 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

pixeltable/exprs/json_path.py

@@ -43,11 +43,11 @@ class JsonPath(Expr):
         self.id = self._create_id()
 
     def __repr__(self) -> str:
-        # else "R": the anchor is RELATIVE_PATH_ROOT
-        return (
-            f'{str(self._anchor) if self._anchor is not None else "R"}'
-            f'{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}'
-        )
+        # else 'R': the anchor is RELATIVE_PATH_ROOT
+        anchor_str = str(self._anchor) if self._anchor is not None else 'R'
+        if len(self.path_elements) == 0:
+            return anchor_str
+        return f'{anchor_str}{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}'
 
     def _as_dict(self) -> dict:
         path_elements = [[el.start, el.stop, el.step] if isinstance(el, slice) else el for el in self.path_elements]
@@ -158,6 +158,7 @@ class JsonPath(Expr):
         return ''.join(result)
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        assert self._anchor is not None, self
         val = data_row[self._anchor.slot_idx]
         if self.compiled_path is not None:
             val = self.compiled_path.search(val)

pixeltable/exprs/object_ref.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
@@ -26,14 +26,22 @@ class ObjectRef(Expr):
         self.owner = owner
         self.id = self._create_id()
 
+    def _id_attrs(self) -> list[tuple[str, Any]]:
+        # We have no components, so we can't rely on the default behavior here (otherwise, all ObjectRef
+        # instances will be conflated into a single slot).
+        return [('addr', id(self))]
+
+    def substitute(self, subs: dict[Expr, Expr]) -> Expr:
+        # Just return self; we need to avoid creating a new id after doing the substitution, because otherwise
+        # we'll wind up in a situation where the scope_anchor of the enclosing JsonMapper is different from the
+        # nested ObjectRefs inside its target_expr (and therefore occupies a different slot_idx).
+        return self
+
     def scope(self) -> ExprScope:
         return self._scope
 
-    def __str__(self) -> str:
-        assert False
-
     def _equals(self, other: ObjectRef) -> bool:
-        return self.owner is other.owner
+        return self.id == other.id
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None
@@ -41,3 +49,6 @@ class ObjectRef(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         # this will be called, but the value has already been materialized elsewhere
         pass
+
+    def __repr__(self) -> str:
+        return f'ObjectRef({self.owner}, {self.id}, {self.owner.id})'

pixeltable/exprs/row_builder.py

@@ -7,17 +7,15 @@ from typing import Any, Iterable, Optional, Sequence
 from uuid import UUID
 
 import numpy as np
-import sqlalchemy as sql
 
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
-import pixeltable.func as func
 import pixeltable.utils as utils
 from pixeltable.env import Env
 from pixeltable.utils.media_store import MediaStore
 
 from .data_row import DataRow
-from .expr import Expr
+from .expr import Expr, ExprScope
 from .expr_set import ExprSet
 
 
@@ -174,11 +172,13 @@ class RowBuilder:
 
         def refs_unstored_iter_col(col_ref: ColumnRef) -> bool:
             tbl = col_ref.col.tbl
-            return tbl.is_component_view() and tbl.is_iterator_column(col_ref.col) and not col_ref.col.is_stored
+            return (
+                tbl.get().is_component_view and tbl.get().is_iterator_column(col_ref.col) and not col_ref.col.is_stored
+            )
 
         unstored_iter_col_refs = [col_ref for col_ref in col_refs if refs_unstored_iter_col(col_ref)]
         component_views = [col_ref.col.tbl for col_ref in unstored_iter_col_refs]
-        unstored_iter_args = {view.id: view.iterator_args.copy() for view in component_views}
+        unstored_iter_args = {view.id: view.get().iterator_args.copy() for view in component_views}
         self.unstored_iter_args = {
             id: self._record_unique_expr(arg, recursive=True) for id, arg in unstored_iter_args.items()
         }
@@ -236,13 +236,6 @@ class RowBuilder:
         """Return ColumnSlotIdx for output columns"""
         return self.table_columns
 
-    def set_conn(self, conn: sql.engine.Connection) -> None:
-        from .function_call import FunctionCall
-
-        for expr in self.unique_exprs:
-            if isinstance(expr, FunctionCall) and isinstance(expr.fn, func.QueryTemplateFunction):
-                expr.fn.set_conn(conn)
-
     @property
     def num_materialized(self) -> int:
         return self.next_slot_idx
@@ -299,6 +292,7 @@ class RowBuilder:
                 # this is input and therefore doesn't depend on other exprs
                 continue
             for d in expr.dependencies():
+                assert d.slot_idx is not None, f'{expr}, {d}'
                 if d.slot_idx in excluded_slot_idxs:
                     continue
                 dependencies[expr.slot_idx].add(d.slot_idx)
@@ -376,7 +370,12 @@ class RowBuilder:
             data_row.set_exc(slot_idx, exc)
 
     def eval(
-        self, data_row: DataRow, ctx: EvalCtx, profile: Optional[ExecProfile] = None, ignore_errors: bool = False
+        self,
+        data_row: DataRow,
+        ctx: EvalCtx,
+        profile: Optional[ExecProfile] = None,
+        ignore_errors: bool = False,
+        force_eval: Optional[ExprScope] = None,
     ) -> None:
         """
         Populates the slots in data_row given in ctx.
@@ -384,10 +383,11 @@ class RowBuilder:
         and omits any of that expr's dependents's eval().
         profile: if present, populated with execution time of each expr.eval() call; indexed by expr.slot_idx
         ignore_errors: if False, raises ExprEvalError if any expr.eval() raises an exception
+        force_eval: forces exprs in the specified scope to be reevaluated, even if they already have a value
         """
         for expr in ctx.exprs:
             assert expr.slot_idx >= 0
-            if data_row.has_val[expr.slot_idx] or data_row.has_exc(expr.slot_idx):
+            if expr.scope() != force_eval and (data_row.has_val[expr.slot_idx] or data_row.has_exc(expr.slot_idx)):
                 continue
             try:
                 start_time = time.perf_counter()
@@ -425,7 +425,7 @@ class RowBuilder:
             else:
                 if col.col_type.is_image_type() and data_row.file_urls[slot_idx] is None:
                     # we have yet to store this image
-                    filepath = str(MediaStore.prepare_media_path(col.tbl.id, col.id, col.tbl.version))
+                    filepath = str(MediaStore.prepare_media_path(col.tbl.id, col.id, col.tbl.get().version))
                     data_row.flush_img(slot_idx, filepath)
                 val = data_row.get_stored_val(slot_idx, col.sa_col.type)
                 table_row[col.store_name()] = val

pixeltable/exprs/rowid_ref.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional, cast
 from uuid import UUID
 
 import sqlalchemy as sql
@@ -13,6 +13,9 @@ from .expr import Expr
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
+if TYPE_CHECKING:
+    from pixeltable import store
+
 
 class RowidRef(Expr):
     """A reference to a part of a table rowid
@@ -23,9 +26,15 @@ class RowidRef(Expr):
     (with and without a TableVersion).
     """
 
+    tbl: Optional[catalog.TableVersionHandle]
+    normalized_base: Optional[catalog.TableVersionHandle]
+    tbl_id: UUID
+    normalized_base_id: UUID
+    rowid_component_idx: int
+
     def __init__(
         self,
-        tbl: catalog.TableVersion,
+        tbl: catalog.TableVersionHandle,
         idx: int,
         tbl_id: Optional[UUID] = None,
         normalized_base_id: Optional[UUID] = None,
@@ -37,8 +46,8 @@ class RowidRef(Expr):
             # (which has the same values as all its descendent views)
             normalized_base = tbl
             # don't try to reference tbl.store_tbl here
-            while normalized_base.base is not None and normalized_base.base.num_rowid_columns() > idx:
-                normalized_base = normalized_base.base
+            while normalized_base.get().base is not None and normalized_base.get().base.get().num_rowid_columns() > idx:
+                normalized_base = normalized_base.get().base
             self.normalized_base = normalized_base
         else:
             self.normalized_base = None
@@ -66,8 +75,13 @@ class RowidRef(Expr):
 
     def __repr__(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:  # type: ignore[attr-defined]
+        from pixeltable import store
+
+        tbl = self.tbl.get() if self.tbl is not None else catalog.Catalog.get().get_tbl_version(self.tbl_id, None)
+        if (
+            tbl.is_component_view
+            and self.rowid_component_idx == cast(store.StoreComponentView, tbl.store_tbl).pos_col_idx
+        ):
             return catalog.globals._POS_COLUMN_NAME
         return ''
 
@@ -85,7 +99,7 @@ class RowidRef(Expr):
         self.tbl_id = self.tbl.id
 
     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)]
+        tbl = self.tbl.get() if self.tbl is not None else catalog.Catalog.get().get_tbl_version(self.tbl_id, None)
         rowid_cols = tbl.store_tbl.rowid_columns()
         return rowid_cols[self.rowid_component_idx]
 

pixeltable/func/__init__.py

@@ -1,7 +1,7 @@
 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/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
@@ -468,11 +471,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 +500,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/query_template_function.py

@@ -21,7 +21,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 +53,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 +67,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 +79,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/tools.py

@@ -48,22 +48,27 @@ class Tool(pydantic.BaseModel):
             'additionalProperties': False,  # TODO Handle kwargs?
         }
 
-    # `tool_calls` must be in standardized tool invocation format:
-    # {tool_name: {'args': {name1: value1, name2: value2, ...}}, ...}
-    def invoke(self, tool_calls: 'exprs.Expr') -> 'exprs.FunctionCall':
-        kwargs = {param.name: self.__extract_tool_arg(param, tool_calls) for param in self.parameters.values()}
-        return self.fn(**kwargs)
+    # The output of `tool_calls` must be a dict in standardized tool invocation format:
+    # {tool_name: [{'args': {name1: value1, name2: value2, ...}}, ...], ...}
+    def invoke(self, tool_calls: 'exprs.Expr') -> 'exprs.Expr':
+        from pixeltable import exprs
 
-    def __extract_tool_arg(self, param: Parameter, tool_calls: 'exprs.Expr') -> 'exprs.Expr':
         func_name = self.name or self.fn.name
+        return exprs.JsonMapper(tool_calls[func_name]['*'], self.__invoke_kwargs(exprs.RELATIVE_PATH_ROOT.args))
+
+    def __invoke_kwargs(self, kwargs: 'exprs.Expr') -> 'exprs.FunctionCall':
+        kwargs = {param.name: self.__extract_tool_arg(param, kwargs) for param in self.parameters.values()}
+        return self.fn(**kwargs)
+
+    def __extract_tool_arg(self, param: Parameter, kwargs: 'exprs.Expr') -> 'exprs.FunctionCall':
         if param.col_type.is_string_type():
-            return _extract_str_tool_arg(tool_calls, func_name=func_name, param_name=param.name)
+            return _extract_str_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_int_type():
-            return _extract_int_tool_arg(tool_calls, func_name=func_name, param_name=param.name)
+            return _extract_int_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_float_type():
-            return _extract_float_tool_arg(tool_calls, func_name=func_name, param_name=param.name)
+            return _extract_float_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_bool_type():
-            return _extract_bool_tool_arg(tool_calls, func_name=func_name, param_name=param.name)
+            return _extract_bool_tool_arg(kwargs, param_name=param.name)
         assert False
 
 
@@ -113,34 +118,29 @@ class Tools(pydantic.BaseModel):
 
 
 @udf
-def _extract_str_tool_arg(tool_calls: dict[str, Any], func_name: str, param_name: str) -> Optional[str]:
-    return _extract_arg(str, tool_calls, func_name, param_name)
+def _extract_str_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[str]:
+    return _extract_arg(str, kwargs, param_name)
 
 
 @udf
-def _extract_int_tool_arg(tool_calls: dict[str, Any], func_name: str, param_name: str) -> Optional[int]:
-    return _extract_arg(int, tool_calls, func_name, param_name)
+def _extract_int_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[int]:
+    return _extract_arg(int, kwargs, param_name)
 
 
 @udf
-def _extract_float_tool_arg(tool_calls: dict[str, Any], func_name: str, param_name: str) -> Optional[float]:
-    return _extract_arg(float, tool_calls, func_name, param_name)
+def _extract_float_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[float]:
+    return _extract_arg(float, kwargs, param_name)
 
 
 @udf
-def _extract_bool_tool_arg(tool_calls: dict[str, Any], func_name: str, param_name: str) -> Optional[bool]:
-    return _extract_arg(bool, tool_calls, func_name, param_name)
+def _extract_bool_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[bool]:
+    return _extract_arg(bool, kwargs, param_name)
 
 
 T = TypeVar('T')
 
 
-def _extract_arg(
-    eval_fn: Callable[[Any], T], tool_calls: dict[str, Any], func_name: str, param_name: str
-) -> Optional[T]:
-    if func_name in tool_calls:
-        arguments = tool_calls[func_name]['args']
-        if param_name in arguments:
-            return eval_fn(arguments[param_name])
-        return None
+def _extract_arg(eval_fn: Callable[[Any], T], kwargs: dict[str, Any], param_name: str) -> Optional[T]:
+    if param_name in kwargs:
+        return eval_fn(kwargs[param_name])
     return None

pixeltable/func/udf.py

@@ -268,7 +268,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 (

pixeltable/functions/anthropic.py

@@ -213,9 +213,15 @@ def invoke_tools(tools: Tools, response: exprs.Expr) -> exprs.InlineDict:
 @pxt.udf
 def _anthropic_response_to_pxt_tool_calls(response: dict) -> Optional[dict]:
     anthropic_tool_calls = [r for r in response['content'] if r['type'] == 'tool_use']
-    if len(anthropic_tool_calls) > 0:
-        return {tool_call['name']: {'args': tool_call['input']} for tool_call in anthropic_tool_calls}
-    return None
+    if len(anthropic_tool_calls) == 0:
+        return None
+    pxt_tool_calls: dict[str, list[dict[str, Any]]] = {}
+    for tool_call in anthropic_tool_calls:
+        tool_name = tool_call['name']
+        if tool_name not in pxt_tool_calls:
+            pxt_tool_calls[tool_name] = []
+        pxt_tool_calls[tool_name].append({'args': tool_call['input']})
+    return pxt_tool_calls
 
 
 _T = TypeVar('_T')

pixeltable/functions/fireworks.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Optional
 
 import pixeltable as pxt
 from pixeltable import env
+from pixeltable.config import Config
 from pixeltable.utils.code import local_public_names
 
 if TYPE_CHECKING:
@@ -41,7 +42,7 @@ async def chat_completions(
     Creates a model response for the given chat conversation.
 
     Equivalent to the Fireworks AI `chat/completions` API endpoint.
-    For additional details, see: [https://docs.fireworks.ai/api-reference/post-chatcompletions](https://docs.fireworks.ai/api-reference/post-chatcompletions)
+    For additional details, see: <https://docs.fireworks.ai/api-reference/post-chatcompletions>
 
     Request throttling:
     Applies the rate limit set in the config (section `fireworks`, key `rate_limit`). If no rate
@@ -55,7 +56,7 @@ async def chat_completions(
         messages: A list of messages comprising the conversation so far.
         model: The name of the model to use.
 
-    For details on the other parameters, see: [https://docs.fireworks.ai/api-reference/post-chatcompletions](https://docs.fireworks.ai/api-reference/post-chatcompletions)
+    For details on the other parameters, see: <https://docs.fireworks.ai/api-reference/post-chatcompletions>
 
     Returns:
         A dictionary containing the response and other metadata.
@@ -65,7 +66,9 @@ async def chat_completions(
         to an existing Pixeltable column `tbl.prompt` of the table `tbl`:
 
         >>> messages = [{'role': 'user', 'content': tbl.prompt}]
-        ... tbl.add_computed_column(response=chat_completions(messages, model='accounts/fireworks/models/mixtral-8x22b-instruct'))
+        ... tbl.add_computed_column(
+        ...     response=chat_completions(messages, model='accounts/fireworks/models/mixtral-8x22b-instruct')
+        ... )
     """
     kwargs = {'max_tokens': max_tokens, 'top_k': top_k, 'top_p': top_p, 'temperature': temperature}
     kwargs_not_none = {k: v for k, v in kwargs.items() if v is not None}
@@ -75,7 +78,7 @@ async def chat_completions(
     # res_sync_dict = res_sync.dict()
 
     if request_timeout is None:
-        request_timeout = env.Env.get().config.get_int_value('timeout', section='fireworks') or 600
+        request_timeout = Config.get().get_int_value('timeout', section='fireworks') or 600
     # TODO: this timeout doesn't really work, I think it only applies to returning the stream, but not to the timing
     # of the chunks; addressing this would require a timeout for the task running this udf
     stream = _fireworks_client().chat.completions.acreate(

pixeltable/functions/globals.py

@@ -6,9 +6,8 @@ from typing import Optional, Union
 
 import sqlalchemy as sql
 
-import pixeltable.func as func
 import pixeltable.type_system as ts
-from pixeltable import exprs
+from pixeltable import exprs, func
 from pixeltable.utils.code import local_public_names
 
 
@@ -50,7 +49,6 @@ def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
 @func.uda(
     allows_window=True,
     # Allow counting non-null values of any type
-    # TODO: I couldn't include "Array" because we don't have a way to represent a generic array (of arbitrary dimension).
     # TODO: should we have an "Any" type that can be used here?
     type_substitutions=tuple(
         {T: Optional[t]}  # type: ignore[misc]
@@ -60,6 +58,7 @@ def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
             ts.Float,
             ts.Bool,
             ts.Timestamp,
+            ts.Array,
             ts.Json,
             ts.Image,
             ts.Video,
@@ -107,7 +106,7 @@ class min(func.Aggregator, typing.Generic[T]):
 
 @min.to_sql
 def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
-    if val.type.python_type == bool:
+    if val.type.python_type is bool:
         # TODO: min/max aggregation of booleans is not supported in Postgres (but it is in Python).
         # Right now we simply force the computation to be done in Python; we might consider implementing an alternate
         # way of doing it in SQL. (min/max of booleans is simply logical and/or, respectively.)
@@ -137,7 +136,7 @@ class max(func.Aggregator, typing.Generic[T]):
 
 @max.to_sql
 def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
-    if val.type.python_type == bool:
+    if val.type.python_type is bool:
         # TODO: see comment in @min.to_sql.
         return None
     return sql.sql.func.max(val)

pixeltable/functions/huggingface.py

@@ -12,8 +12,8 @@ from typing import Any, Callable, Optional, TypeVar
 import PIL.Image
 
 import pixeltable as pxt
-import pixeltable.env as env
 import pixeltable.exceptions as excs
+from pixeltable import env
 from pixeltable.func import Batch
 from pixeltable.functions.util import normalize_image_mode, resolve_torch_device
 from pixeltable.utils.code import local_public_names
@@ -50,7 +50,6 @@ def sentence_transformer(
     """
     env.Env.get().require_package('sentence_transformers')
     device = resolve_torch_device('auto')
-    import torch
     from sentence_transformers import SentenceTransformer  # type: ignore
 
     # specifying the device, moves the model to device (gpu:cuda/mps, cpu)
@@ -76,7 +75,6 @@ def _(model_id: str) -> pxt.ArrayType:
 def sentence_transformer_list(sentences: list, *, model_id: str, normalize_embeddings: bool = False) -> list:
     env.Env.get().require_package('sentence_transformers')
     device = resolve_torch_device('auto')
-    import torch
     from sentence_transformers import SentenceTransformer
 
     # specifying the device, moves the model to device (gpu:cuda/mps, cpu)
@@ -117,7 +115,6 @@ def cross_encoder(sentences1: Batch[str], sentences2: Batch[str], *, model_id: s
     """
     env.Env.get().require_package('sentence_transformers')
     device = resolve_torch_device('auto')
-    import torch
     from sentence_transformers import CrossEncoder
 
     # specifying the device, moves the model to device (gpu:cuda/mps, cpu)
@@ -132,7 +129,6 @@ def cross_encoder(sentences1: Batch[str], sentences2: Batch[str], *, model_id: s
 def cross_encoder_list(sentence1: str, sentences2: list, *, model_id: str) -> list:
     env.Env.get().require_package('sentence_transformers')
     device = resolve_torch_device('auto')
-    import torch
     from sentence_transformers import CrossEncoder
 
     # specifying the device, moves the model to device (gpu:cuda/mps, cpu)