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

pixeltable/exprs/function_call.py

@@ -3,16 +3,12 @@ from __future__ import annotations
 import inspect
 import logging
 import sys
-import warnings
 from textwrap import dedent
 from typing import Any, Optional, Sequence, Union
 
 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, exceptions as excs, func, type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
@@ -156,22 +152,18 @@ class FunctionCall(Expr):
         return self.fn.name
 
     def _equals(self, other: FunctionCall) -> bool:
-        if self.fn != other.fn:
-            return False
-        if self.arg_idxs != other.arg_idxs:
-            return False
-        if self.kwarg_idxs != other.kwarg_idxs:
-            return False
-        if self.group_by_start_idx != other.group_by_start_idx:
-            return False
-        if self.group_by_stop_idx != other.group_by_stop_idx:
-            return False
-        if self.order_by_start_idx != other.order_by_start_idx:
-            return False
-        return True
+        return (
+            self.fn == other.fn
+            and self.arg_idxs == other.arg_idxs
+            and self.kwarg_idxs == other.kwarg_idxs
+            and self.group_by_start_idx == other.group_by_start_idx
+            and self.group_by_stop_idx == other.group_by_stop_idx
+            and self.order_by_start_idx == other.order_by_start_idx
+        )
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [
+        return [
+            *super()._id_attrs(),
             ('fn', id(self.fn)),  # use the function pointer, not the fqn, which isn't set for lambdas
             ('args', self.arg_idxs),
             ('kwargs', self.kwarg_idxs),
@@ -192,12 +184,12 @@ class FunctionCall(Expr):
         if self.is_method_call:
             return f'{self.components[0]}.{self.fn.name}({self._print_args(1, inline)})'
         else:
-            fn_name = self.fn.display_name if self.fn.display_name != '' else 'anonymous_fn'
+            fn_name = self.fn.display_name or 'anonymous_fn'
             return f'{fn_name}({self._print_args()})'
 
     def _print_args(self, start_idx: int = 0, inline: bool = True) -> str:
         arg_strs = [str(self.components[idx]) for idx in self.arg_idxs[start_idx:]]
-        arg_strs.extend([f'{param_name}={str(self.components[idx])}' for param_name, idx in self.kwarg_idxs.items()])
+        arg_strs.extend([f'{param_name}={self.components[idx]}' for param_name, idx in self.kwarg_idxs.items()])
         if len(self.order_by) > 0:
             assert isinstance(self.fn, func.AggregateFunction)
             if self.fn.requires_order_by:
@@ -297,7 +289,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters_by_pos[idx].kind
-                in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+                in {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
                 and not parameters_by_pos[idx].col_type.nullable
             ):
                 return None
@@ -310,7 +302,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters[param_name].kind
-                in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+                in {inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
                 and not parameters[param_name].col_type.nullable
             ):
                 return None
@@ -368,10 +360,7 @@ class FunctionCall(Expr):
             return
         args, kwargs = args_kwargs
 
-        if isinstance(self.fn, func.CallableFunction) and not self.fn.is_batched:
-            # optimization: avoid additional level of indirection we'd get from calling Function.exec()
-            data_row[self.slot_idx] = self.fn.py_fn(*args, **kwargs)
-        elif self.is_window_fn_call:
+        if self.is_window_fn_call:
             assert isinstance(self.fn, func.AggregateFunction)
             agg_cls = self.fn.agg_class
             if self.has_group_by():
@@ -466,20 +455,18 @@ class FunctionCall(Expr):
                 # the call_return_type that we just inferred (which matches the deserialization behavior prior to
                 # version 25).
                 return_type = call_return_type
-            else:
-                # There is a return_type stored in metadata (schema version >= 25).
-                # Check that the stored return_type of the UDF call matches the column type of the FunctionCall, and
-                # fail-fast if it doesn't (otherwise we risk getting downstream database errors).
-                if not return_type.is_supertype_of(call_return_type, ignore_nullable=True):
-                    validation_error = dedent(
-                        f"""
-                        The return type stored in the database for a UDF call to {fn.self_path!r} no longer
-                        matches its return type as currently defined in the code. This probably means that the
-                        code for {fn.self_path!r} has changed in a backward-incompatible way.
-                        Return type of UDF call in the database: {return_type}
-                        Return type of UDF as currently defined in code: {call_return_type}
-                        """
-                    ).strip()
+            elif not return_type.is_supertype_of(call_return_type, ignore_nullable=True):
+                # There is a return_type stored in metadata (schema version >= 25),
+                # and the stored return_type of the UDF call doesn't match the column type of the FunctionCall.
+                validation_error = dedent(
+                    f"""
+                    The return type stored in the database for a UDF call to {fn.self_path!r} no longer
+                    matches its return type as currently defined in the code. This probably means that the
+                    code for {fn.self_path!r} has changed in a backward-incompatible way.
+                    Return type of UDF call in the database: {return_type}
+                    Return type of UDF as currently defined in code: {call_return_type}
+                    """
+                ).strip()
 
         fn_call = cls(
             resolved_fn,

pixeltable/exprs/globals.py

@@ -36,7 +36,7 @@ class ComparisonOperator(enum.Enum):
             return '>'
         if self == self.GE:
             return '>='
-        assert False
+        raise AssertionError()
 
     def reverse(self) -> ComparisonOperator:
         if self == self.LT:
@@ -62,7 +62,7 @@ class LogicalOperator(enum.Enum):
             return '|'
         if self == self.NOT:
             return '~'
-        assert False
+        raise AssertionError()
 
 
 class ArithmeticOperator(enum.Enum):
@@ -86,4 +86,4 @@ class ArithmeticOperator(enum.Enum):
             return '%'
         if self == self.FLOORDIV:
             return '//'
-        assert False
+        raise AssertionError()

pixeltable/exprs/in_predicate.py

@@ -71,7 +71,7 @@ class InPredicate(Expr):
         return self.value_list == other.value_list
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('value_list', self.value_list)]
+        return [*super()._id_attrs(), ('value_list', self.value_list)]
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         lhs_sql_exprs = sql_elements.get(self.components[0])

pixeltable/exprs/inline_expr.py

@@ -131,7 +131,7 @@ class InlineList(Expr):
     def as_literal(self) -> Optional[Literal]:
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
-        return Literal(list(c.as_literal().val for c in self.components), self.col_type)
+        return Literal([c.as_literal().val for c in self.components], self.col_type)
 
 
 class InlineDict(Expr):
@@ -166,7 +166,7 @@ class InlineDict(Expr):
         self.id = self._create_id()
 
     def __repr__(self) -> str:
-        item_strs = list(f"'{key}': {str(expr)}" for key, expr in zip(self.keys, self.components))
+        item_strs = [f"'{key}': {expr}" for key, expr in zip(self.keys, self.components)]
         return '{' + ', '.join(item_strs) + '}'
 
     def _equals(self, other: InlineDict) -> bool:
@@ -174,7 +174,7 @@ class InlineDict(Expr):
         return self.keys == other.keys
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('keys', self.keys)]
+        return [*super()._id_attrs(), ('keys', self.keys)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None

pixeltable/exprs/is_null.py

@@ -19,7 +19,7 @@ class IsNull(Expr):
         self.id = self._create_id()
 
     def __repr__(self) -> str:
-        return f'{str(self.components[0])} == None'
+        return f'{self.components[0]} == None'
 
     def _equals(self, other: IsNull) -> bool:
         return True

pixeltable/exprs/json_mapper.py

@@ -48,9 +48,9 @@ class JsonMapper(Expr):
         scope_anchor = ObjectRef(self.target_expr_scope, self)
         self.components.append(scope_anchor)
 
-    def bind_rel_paths(self, mapper: Optional[JsonMapper] = None) -> None:
-        self._src_expr.bind_rel_paths(mapper)
-        self._target_expr.bind_rel_paths(self)
+    def _bind_rel_paths(self, mapper: Optional[JsonMapper] = None) -> None:
+        self._src_expr._bind_rel_paths(mapper)
+        self._target_expr._bind_rel_paths(self)
         self.parent_mapper = mapper
         parent_scope = _GLOBAL_SCOPE if mapper is None else mapper.target_expr_scope
         self.target_expr_scope.parent = parent_scope
@@ -81,12 +81,12 @@ class JsonMapper(Expr):
         """
         We override equals() because we need to avoid comparing our scope anchor.
         """
-        if type(self) != type(other):
+        if type(self) is not type(other):
             return False
         return self._src_expr.equals(other._src_expr) and self._target_expr.equals(other._target_expr)
 
     def __repr__(self) -> str:
-        return f'{str(self._src_expr)} >> {str(self._target_expr)}'
+        return f'{self._src_expr} >> {self._target_expr}'
 
     @property
     def _src_expr(self) -> Expr:

pixeltable/exprs/json_path.py

@@ -6,14 +6,13 @@ import jmespath
 import sqlalchemy as sql
 
 import pixeltable as pxt
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
+from pixeltable import catalog, exceptions as excs, type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
 from .globals import print_slice
 from .json_mapper import JsonMapper
+from .object_ref import ObjectRef
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
@@ -50,8 +49,16 @@ class JsonPath(Expr):
         return f'{anchor_str}{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}'
 
     def _as_dict(self) -> dict:
+        assert len(self.components) <= 1
+        components_dict: dict[str, Any]
+        if len(self.components) == 0 or isinstance(self.components[0], ObjectRef):
+            # If the anchor is an ObjectRef, it means this JsonPath is a bound relative path. We store it as a relative
+            # path, *not* a bound path (which has no meaning in the dict).
+            components_dict = {}
+        else:
+            components_dict = super()._as_dict()
         path_elements = [[el.start, el.stop, el.step] if isinstance(el, slice) else el for el in self.path_elements]
-        return {'path_elements': path_elements, 'scope_idx': self.scope_idx, **super()._as_dict()}
+        return {'path_elements': path_elements, 'scope_idx': self.scope_idx, **components_dict}
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> JsonPath:
@@ -73,29 +80,34 @@ class JsonPath(Expr):
     def is_relative_path(self) -> bool:
         return self._anchor is None
 
-    def bind_rel_paths(self, mapper: Optional['JsonMapper'] = None) -> None:
-        if not self.is_relative_path():
-            return
-        # TODO: take scope_idx into account
-        self.set_anchor(mapper.scope_anchor)
+    @property
+    def _has_relative_path(self) -> bool:
+        return self.is_relative_path() or super()._has_relative_path
+
+    def _bind_rel_paths(self, mapper: Optional['JsonMapper'] = None) -> None:
+        if self.is_relative_path():
+            # TODO: take scope_idx into account
+            self.set_anchor(mapper.scope_anchor)
+        else:
+            self._anchor._bind_rel_paths(mapper)
 
     def __call__(self, *args: object, **kwargs: object) -> 'JsonPath':
         """
         Construct a relative path that references an ancestor of the immediately enclosing JsonMapper.
         """
         if not self.is_relative_path():
-            raise excs.Error(f'() for an absolute path is invalid')
+            raise excs.Error('() for an absolute path is invalid')
         if len(args) != 1 or not isinstance(args[0], int) or args[0] >= 0:
-            raise excs.Error(f'R() requires a negative index')
+            raise excs.Error('R() requires a negative index')
         return JsonPath(None, [], args[0])
 
     def __getattr__(self, name: str) -> 'JsonPath':
         assert isinstance(name, str)
-        return JsonPath(self._anchor, self.path_elements + [name])
+        return JsonPath(self._anchor, [*self.path_elements, name])
 
     def __getitem__(self, index: object) -> 'JsonPath':
         if isinstance(index, (int, slice, str)):
-            return JsonPath(self._anchor, self.path_elements + [index])
+            return JsonPath(self._anchor, [*self.path_elements, index])
         raise excs.Error(f'Invalid json list index: {index}')
 
     def __rshift__(self, other: object) -> 'JsonMapper':
@@ -120,7 +132,7 @@ class JsonPath(Expr):
 
         clean_name = ''.join(map(cleanup_char, ret_name))
         clean_name = clean_name.lstrip('_')  # remove leading underscore
-        if clean_name == '':
+        if not clean_name:  # Replace '' with None
             clean_name = None
 
         assert clean_name is None or catalog.is_valid_identifier(clean_name)
@@ -130,7 +142,7 @@ class JsonPath(Expr):
         return self.path_elements == other.path_elements
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('path_elements', self.path_elements)]
+        return [*super()._id_attrs(), ('path_elements', self.path_elements)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         """

pixeltable/exprs/literal.py

@@ -62,7 +62,7 @@ class Literal(Expr):
         return self.val == other.val
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('val', self.val)]
+        return [*super()._id_attrs(), ('val', self.val)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         # Return a sql object so that constants can participate in SQL expressions

pixeltable/exprs/method_ref.py

@@ -53,13 +53,13 @@ class MethodRef(Expr):
         return self.base_expr.id == other.base_expr.id and self.method_name == other.method_name
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('method_name', self.method_name)]
+        return [*super()._id_attrs(), ('method_name', self.method_name)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
-        assert False, 'MethodRef cannot be evaluated directly'
+        raise AssertionError('MethodRef cannot be evaluated directly')
 
     def __repr__(self) -> str:
         return f'{self.base_expr}.{self.method_name}'

pixeltable/exprs/row_builder.py

@@ -8,9 +8,7 @@ from uuid import UUID
 
 import numpy as np
 
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.utils as utils
+from pixeltable import catalog, exceptions as excs, utils
 from pixeltable.env import Env
 from pixeltable.utils.media_store import MediaStore
 
@@ -366,8 +364,8 @@ class RowBuilder:
     def set_exc(self, data_row: DataRow, slot_idx: int, exc: Exception) -> None:
         """Record an exception in data_row and propagate it to dependents"""
         data_row.set_exc(slot_idx, exc)
-        for slot_idx in self._exc_dependents[slot_idx]:
-            data_row.set_exc(slot_idx, exc)
+        for idx in self._exc_dependents[slot_idx]:
+            data_row.set_exc(idx, exc)
 
     def eval(
         self,

pixeltable/exprs/rowid_ref.py

@@ -1,21 +1,17 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, cast
+from typing import Any, Optional, cast
 from uuid import UUID
 
 import sqlalchemy as sql
 
-import pixeltable.catalog as catalog
-import pixeltable.type_system as ts
+from pixeltable import catalog, type_system as ts
 
 from .data_row import DataRow
 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
@@ -68,7 +64,8 @@ class RowidRef(Expr):
         )
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [
+        return [
+            *super()._id_attrs(),
             ('normalized_base_id', self.normalized_base_id),
             ('idx', self.rowid_component_idx),
         ]

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,3 +1,5 @@
+# ruff: noqa: F401
+
 from .aggregate_function import AggregateFunction, Aggregator, uda
 from .callable_function import CallableFunction
 from .expr_template_function import ExprTemplateFunction

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

@@ -8,6 +8,7 @@ from uuid import UUID
 import cloudpickle  # type: ignore[import-untyped]
 
 import pixeltable.exceptions as excs
+from pixeltable.utils.coroutine import run_coroutine_synchronously
 
 from .function import Function
 from .signature import Signature
@@ -93,16 +94,17 @@ class CallableFunction(Function):
             batched_kwargs = {k: [v] for k, v in kwargs.items() if k not in constant_param_names}
             result: list[Any]
             if inspect.iscoroutinefunction(self.py_fn):
-                result = asyncio.run(self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs))
+                # TODO: This is temporary (see note in utils/coroutine.py)
+                result = run_coroutine_synchronously(self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs))
             else:
                 result = self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
             assert len(result) == 1
             return result[0]
+        elif inspect.iscoroutinefunction(self.py_fn):
+            # TODO: This is temporary (see note in utils/coroutine.py)
+            return run_coroutine_synchronously(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.