pixeltable 0.3.14__py3-none-any.whl → 0.5.7__py3-none-any.whl

pixeltable/func/mcp.py

@@ -0,0 +1,74 @@
+import asyncio
+import inspect
+from typing import TYPE_CHECKING, Any
+
+import pixeltable as pxt
+from pixeltable import exceptions as excs, type_system as ts
+from pixeltable.func.signature import Parameter
+
+if TYPE_CHECKING:
+    import mcp
+
+
+def mcp_udfs(url: str) -> list['pxt.func.Function']:
+    return asyncio.run(mcp_udfs_async(url))
+
+
+async def mcp_udfs_async(url: str) -> list['pxt.func.Function']:
+    import mcp
+    from mcp.client.streamable_http import streamablehttp_client
+
+    list_tools_result: mcp.types.ListToolsResult | None = None
+    async with (
+        streamablehttp_client(url) as (read_stream, write_stream, _),
+        mcp.ClientSession(read_stream, write_stream) as session,
+    ):
+        await session.initialize()
+        list_tools_result = await session.list_tools()
+    assert list_tools_result is not None
+
+    return [mcp_tool_to_udf(url, tool) for tool in list_tools_result.tools]
+
+
+def mcp_tool_to_udf(url: str, mcp_tool: 'mcp.types.Tool') -> 'pxt.func.Function':
+    import mcp
+    from mcp.client.streamable_http import streamablehttp_client
+
+    async def invoke(**kwargs: Any) -> str:
+        # TODO: Cache session objects rather than creating a new one each time?
+        async with (
+            streamablehttp_client(url) as (read_stream, write_stream, _),
+            mcp.ClientSession(read_stream, write_stream) as session,
+        ):
+            await session.initialize()
+            res = await session.call_tool(name=mcp_tool.name, arguments=kwargs)
+            # TODO Handle image/audio responses?
+            return res.content[0].text  # type: ignore[union-attr]
+
+    if mcp_tool.description is not None:
+        invoke.__doc__ = mcp_tool.description
+
+    input_schema = mcp_tool.inputSchema
+    params = {
+        name: __mcp_param_to_pxt_type(mcp_tool.name, name, param) for name, param in input_schema['properties'].items()
+    }
+    required = input_schema.get('required', [])
+
+    # Ensure that any params not appearing in `required` are nullable.
+    # (A required param might or might not be nullable, since its type might be an 'anyOf' containing a null.)
+    for name in params.keys() - required:
+        params[name] = params[name].copy(nullable=True)
+
+    signature = pxt.func.Signature(
+        return_type=ts.StringType(),  # Return type is always string
+        parameters=[Parameter(name, col_type, inspect.Parameter.KEYWORD_ONLY) for name, col_type in params.items()],
+    )
+
+    return pxt.func.CallableFunction(signatures=[signature], py_fns=[invoke], self_name=mcp_tool.name)
+
+
+def __mcp_param_to_pxt_type(tool_name: str, name: str, param: dict[str, Any]) -> ts.ColumnType:
+    pxt_type = ts.ColumnType.from_json_schema(param)
+    if pxt_type is None:
+        raise excs.Error(f'Unknown type schema for MCP parameter {name!r} of tool {tool_name!r}: {param}')
+    return pxt_type

pixeltable/func/query_template_function.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import inspect
 from functools import reduce
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, Iterable, overload
 
 from pixeltable import catalog, exceptions as excs, exprs, func, type_system as ts
 
@@ -10,41 +10,41 @@ from .function import Function
 from .signature import Signature
 
 if TYPE_CHECKING:
-    from pixeltable import DataFrame
+    from pixeltable import Query
 
 
 class QueryTemplateFunction(Function):
-    """A parameterized query/DataFrame from which an executable DataFrame is created with a function call."""
+    """A parameterized query from which an executable Query is created with a function call."""
 
-    template_df: Optional['DataFrame']
-    self_name: Optional[str]
-    _comment: Optional[str]
+    template_df: 'Query' | None
+    self_name: str | None
+    _comment: str | None
 
     @classmethod
     def create(
-        cls, template_callable: Callable, param_types: Optional[list[ts.ColumnType]], path: str, name: str
+        cls, template_callable: Callable, param_types: list[ts.ColumnType] | None, 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
+        # invoke template_callable with parameter expressions to construct a Query with parameters
         var_exprs = [exprs.Variable(param.name, param.col_type) for param in params]
         template_df = template_callable(*var_exprs)
-        from pixeltable import DataFrame
+        from pixeltable import Query
 
-        assert isinstance(template_df, DataFrame)
+        assert isinstance(template_df, Query)
         # we take params and return json
         sig = Signature(return_type=ts.JsonType(), parameters=params)
         return QueryTemplateFunction(template_df, sig, path=path, name=name, comment=inspect.getdoc(template_callable))
 
     def __init__(
         self,
-        template_df: Optional['DataFrame'],
+        template_df: 'Query' | None,
         sig: Signature,
-        path: Optional[str] = None,
-        name: Optional[str] = None,
-        comment: Optional[str] = None,
+        path: str | None = None,
+        name: str | None = None,
+        comment: str | None = None,
     ):
         assert sig is not None
         super().__init__([sig], self_path=path)
@@ -82,7 +82,7 @@ class QueryTemplateFunction(Function):
     def name(self) -> str:
         return self.self_name
 
-    def comment(self) -> Optional[str]:
+    def comment(self) -> str | None:
         return self._comment
 
     def _as_dict(self) -> dict:
@@ -90,9 +90,9 @@ class QueryTemplateFunction(Function):
 
     @classmethod
     def _from_dict(cls, d: dict) -> Function:
-        from pixeltable.dataframe import DataFrame
+        from pixeltable._query import Query
 
-        return cls(DataFrame.from_dict(d['df']), Signature.from_dict(d['signature']), name=d['name'])
+        return cls(Query.from_dict(d['df']), Signature.from_dict(d['signature']), name=d['name'])
 
 
 @overload
@@ -100,11 +100,11 @@ def query(py_fn: Callable) -> QueryTemplateFunction: ...
 
 
 @overload
-def query(*, param_types: Optional[list[ts.ColumnType]] = None) -> Callable[[Callable], QueryTemplateFunction]: ...
+def query(*, param_types: list[ts.ColumnType] | None = None) -> Callable[[Callable], QueryTemplateFunction]: ...
 
 
 def query(*args: Any, **kwargs: Any) -> Any:
-    def make_query_template(py_fn: Callable, param_types: Optional[list[ts.ColumnType]]) -> QueryTemplateFunction:
+    def make_query_template(py_fn: Callable, param_types: list[ts.ColumnType] | None) -> QueryTemplateFunction:
         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__}'
@@ -127,10 +127,10 @@ def query(*args: Any, **kwargs: Any) -> Any:
 
 def retrieval_udf(
     table: catalog.Table,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    parameters: Optional[Iterable[Union[str, exprs.ColumnRef]]] = None,
-    limit: Optional[int] = 10,
+    name: str | None = None,
+    description: str | None = None,
+    parameters: Iterable[str | exprs.ColumnRef] | None = None,
+    limit: int | None = 10,
 ) -> func.QueryTemplateFunction:
     """
     Constructs a retrieval UDF for the given table. The retrieval UDF is a UDF whose parameters are
@@ -157,18 +157,20 @@ def retrieval_udf(
     """
     # Argument validation
     col_refs: list[exprs.ColumnRef]
+    # TODO: get rid of references to ColumnRef internals and replace instead with a public interface
+    col_names = table.columns()
     if parameters is None:
-        col_refs = [table[col_name] for col_name in table.columns if not table[col_name].col.is_computed]
+        col_refs = [table[col_name] for col_name in col_names if not table[col_name].col.is_computed]
     else:
         for param in parameters:
-            if isinstance(param, str) and param not in table.columns:
-                raise excs.Error(f'The specified parameter {param!r} is not a column of the table {table._path!r}')
+            if isinstance(param, str) and param not in col_names:
+                raise excs.Error(f'The specified parameter {param!r} is not a column of the table {table._path()!r}')
         col_refs = [table[param] if isinstance(param, str) else param for param in parameters]
 
     if len(col_refs) == 0:
         raise excs.Error('Parameter list cannot be empty.')
 
-    # Construct the dataframe
+    # Construct the Query
     predicates = [col_ref == exprs.Variable(col_ref.col.name, col_ref.col.col_type) for col_ref in col_refs]
     where_clause = reduce(lambda c1, c2: c1 & c2, predicates)
     df = table.select().where(where_clause)

pixeltable/func/signature.py

@@ -4,7 +4,7 @@ import dataclasses
 import inspect
 import logging
 import typing
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional
+from typing import TYPE_CHECKING, Any, Callable, ClassVar
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -18,11 +18,11 @@ _logger = logging.getLogger('pixeltable')
 @dataclasses.dataclass
 class Parameter:
     name: str
-    col_type: Optional[ts.ColumnType]  # None for variable parameters
+    col_type: ts.ColumnType | None  # None for variable parameters
     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: Optional['exprs.Literal'] = None  # default value for the parameter
+    default: 'exprs.Literal' | None = None  # default value for the parameter
     is_batched: bool = False  # True if the parameter is a batched parameter (eg, Batch[dict])
 
     def __post_init__(self) -> None:
@@ -84,8 +84,28 @@ class Signature:
     """
 
     SPECIAL_PARAM_NAMES: ClassVar[list[str]] = ['group_by', 'order_by']
-
-    def __init__(self, return_type: ts.ColumnType, parameters: list[Parameter], is_batched: bool = False):
+    SYSTEM_PARAM_NAMES: ClassVar[list[str]] = ['_runtime_ctx']
+
+    return_type: ts.ColumnType
+    is_batched: bool
+    parameters: dict[str, Parameter]  # name -> Parameter
+    parameters_by_pos: list[Parameter]  # ordered by position in the signature
+    constant_parameters: list[Parameter]  # parameters that are not batched
+    batched_parameters: list[Parameter]  # parameters that are batched
+    required_parameters: list[Parameter]  # parameters that do not have a default value
+
+    # the names of recognized system parameters in the signature; these are excluded from self.parameters
+    system_parameters: list[str]
+
+    py_signature: inspect.Signature
+
+    def __init__(
+        self,
+        return_type: ts.ColumnType,
+        parameters: list[Parameter],
+        is_batched: bool = False,
+        system_parameters: list[str] | None = None,
+    ):
         assert isinstance(return_type, ts.ColumnType)
         self.return_type = return_type
         self.is_batched = is_batched
@@ -95,6 +115,7 @@ class Signature:
         self.constant_parameters = [p for p in parameters if not p.is_batched]
         self.batched_parameters = [p for p in parameters if p.is_batched]
         self.required_parameters = [p for p in parameters if not p.has_default()]
+        self.system_parameters = system_parameters if system_parameters is not None else []
         self.py_signature = inspect.Signature([p.to_py_param() for p in self.parameters_by_pos])
 
     def get_return_type(self) -> ts.ColumnType:
@@ -151,12 +172,12 @@ class Signature:
 
         return True
 
-    def validate_args(self, bound_args: dict[str, Optional['exprs.Expr']], context: str = '') -> None:
+    def validate_args(self, bound_args: dict[str, 'exprs.Expr' | None], context: str = '') -> None:
         if context:
             context = f' ({context})'
 
         for param_name, arg in bound_args.items():
-            assert param_name in self.parameters
+            assert param_name in self.parameters, f'{param_name!r} not in {list(self.parameters.keys())}'
             param = self.parameters[param_name]
             is_var_param = param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}
             if is_var_param:
@@ -206,15 +227,15 @@ class Signature:
             elif p.kind == inspect.Parameter.VAR_KEYWORD:
                 param_strs.append(f'**{p.name}')
             else:
-                param_strs.append(f'{p.name}: {p.col_type}')
-        return f'({", ".join(param_strs)}) -> {self.get_return_type()}'
+                param_strs.append(f'{p.name}: pxt.{p.col_type}')
+        return f'({", ".join(param_strs)}) -> pxt.{self.get_return_type()}'
 
     @classmethod
-    def _infer_type(cls, annotation: Optional[type]) -> tuple[Optional[ts.ColumnType], Optional[bool]]:
+    def _infer_type(cls, annotation: type | None) -> tuple[ts.ColumnType | None, bool | None]:
         """Returns: (column type, is_batched) or (None, ...) if the type cannot be inferred"""
         if annotation is None:
             return (None, None)
-        py_type: Optional[type] = None
+        py_type: type | None = None
         is_batched = False
         if typing.get_origin(annotation) == typing.Annotated:
             type_args = typing.get_args(annotation)
@@ -231,12 +252,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,
-        type_substitutions: Optional[dict] = None,
+        py_fn: Callable | None = None,
+        py_params: list[inspect.Parameter] | None = None,
+        param_types: list[ts.ColumnType] | None = None,
+        type_substitutions: dict | None = None,
         is_cls_method: bool = False,
     ) -> list[Parameter]:
+        """Ignores parameters starting with '_'."""
         from pixeltable import exprs
 
         assert (py_fn is None) != (py_params is None)
@@ -251,6 +273,10 @@ class Signature:
         for idx, param in enumerate(py_params):
             if is_cls_method and idx == 0:
                 continue  # skip 'self' or 'cls' parameter
+            if param.name in cls.SYSTEM_PARAM_NAMES:
+                continue  # skip system parameters
+            if param.name.startswith('_'):
+                raise excs.Error(f"{param.name!r}: parameters starting with '_' are reserved")
             if param.name in cls.SPECIAL_PARAM_NAMES:
                 raise excs.Error(f'{param.name!r} is a reserved parameter name')
             if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
@@ -284,9 +310,9 @@ class Signature:
     def create(
         cls,
         py_fn: Callable,
-        param_types: Optional[list[ts.ColumnType]] = None,
-        return_type: Optional[ts.ColumnType] = None,
-        type_substitutions: Optional[dict] = None,
+        param_types: list[ts.ColumnType] | None = None,
+        return_type: ts.ColumnType | None = None,
+        type_substitutions: dict | None = None,
         is_cls_method: bool = False,
     ) -> Signature:
         """Create a signature for the given Callable.
@@ -308,5 +334,6 @@ class Signature:
                 raise excs.Error('Cannot infer pixeltable return type')
         else:
             _, return_is_batched = cls._infer_type(sig.return_annotation)
+        system_params = [param_name for param_name in sig.parameters if param_name in cls.SYSTEM_PARAM_NAMES]
 
-        return Signature(return_type, parameters, return_is_batched)
+        return Signature(return_type, parameters, return_is_batched, system_parameters=system_params)

pixeltable/func/tools.py

@@ -1,8 +1,10 @@
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
+import json
+import uuid
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
 
 import pydantic
 
-import pixeltable.exceptions as excs
+from pixeltable import exceptions as excs, type_system as ts
 
 from .function import Function
 from .signature import Parameter
@@ -28,8 +30,8 @@ class Tool(pydantic.BaseModel):
     model_config = pydantic.ConfigDict(arbitrary_types_allowed=True)
 
     fn: Function
-    name: Optional[str] = None
-    description: Optional[str] = None
+    name: str | None = None
+    description: str | None = None
 
     @property
     def parameters(self) -> dict[str, Parameter]:
@@ -69,13 +71,17 @@ 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)
-        raise AssertionError()
+        if param.col_type.is_json_type():
+            return _extract_json_tool_arg(kwargs, param_name=param.name)
+        if param.col_type.is_uuid_type():
+            return _extract_uuid_tool_arg(kwargs, param_name=param.name)
+        raise AssertionError(param.col_type)
 
 
 class ToolChoice(pydantic.BaseModel):
     auto: bool
     required: bool
-    tool: Optional[str]
+    tool: str | None
     parallel_tool_calls: bool
 
 
@@ -97,12 +103,12 @@ class Tools(pydantic.BaseModel):
         self,
         auto: bool = False,
         required: bool = False,
-        tool: Union[str, Function, None] = None,
+        tool: str | Function | None = None,
         parallel_tool_calls: bool = True,
     ) -> ToolChoice:
         if sum([auto, required, tool is not None]) != 1:
             raise excs.Error('Exactly one of `auto`, `required`, or `tool` must be specified.')
-        tool_name: Optional[str] = None
+        tool_name: str | None = None
         if tool is not None:
             try:
                 tool_obj = next(
@@ -118,29 +124,41 @@ class Tools(pydantic.BaseModel):
 
 
 @udf
-def _extract_str_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[str]:
+def _extract_str_tool_arg(kwargs: dict[str, Any], param_name: str) -> str | None:
     return _extract_arg(str, kwargs, param_name)
 
 
 @udf
-def _extract_int_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[int]:
+def _extract_int_tool_arg(kwargs: dict[str, Any], param_name: str) -> int | None:
     return _extract_arg(int, kwargs, param_name)
 
 
 @udf
-def _extract_float_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[float]:
+def _extract_float_tool_arg(kwargs: dict[str, Any], param_name: str) -> float | None:
     return _extract_arg(float, kwargs, param_name)
 
 
 @udf
-def _extract_bool_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[bool]:
+def _extract_bool_tool_arg(kwargs: dict[str, Any], param_name: str) -> bool | None:
     return _extract_arg(bool, kwargs, param_name)
 
 
+@udf
+def _extract_json_tool_arg(kwargs: dict[str, Any], param_name: str) -> ts.Json | None:
+    if param_name in kwargs:
+        return json.loads(kwargs[param_name])
+    return None
+
+
+@udf
+def _extract_uuid_tool_arg(kwargs: dict[str, Any], param_name: str) -> uuid.UUID | None:
+    return _extract_arg(uuid.UUID, kwargs, param_name)
+
+
 T = TypeVar('T')
 
 
-def _extract_arg(eval_fn: Callable[[Any], T], kwargs: dict[str, Any], param_name: str) -> Optional[T]:
+def _extract_arg(eval_fn: Callable[[Any], T], kwargs: dict[str, Any], param_name: str) -> T | None:
     if param_name in kwargs:
         return eval_fn(kwargs[param_name])
     return None

pixeltable/func/udf.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, overload
+from typing import TYPE_CHECKING, Any, Callable, Sequence, overload
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -26,12 +26,12 @@ def udf(decorated_fn: Callable) -> CallableFunction: ...
 @overload
 def udf(
     *,
-    batch_size: Optional[int] = None,
-    substitute_fn: Optional[Callable] = None,
+    batch_size: int | None = None,
+    substitute_fn: Callable | None = None,
     is_method: bool = False,
     is_property: bool = False,
-    resource_pool: Optional[str] = None,
-    type_substitutions: Optional[Sequence[dict]] = None,
+    resource_pool: str | None = None,
+    type_substitutions: Sequence[dict] | None = None,
     _force_stored: bool = False,
 ) -> Callable[[Callable], CallableFunction]: ...
 
@@ -39,7 +39,7 @@ def udf(
 # pxt.udf() called explicitly on a Table:
 @overload
 def udf(
-    table: catalog.Table, /, *, return_value: Any = None, description: Optional[str] = None
+    table: catalog.Table, /, *, return_value: Any = None, description: str | None = None
 ) -> ExprTemplateFunction: ...
 
 
@@ -96,15 +96,15 @@ def udf(*args, **kwargs):  # type: ignore[no-untyped-def]
 
 def make_function(
     decorated_fn: Callable,
-    return_type: Optional[ts.ColumnType] = None,
-    param_types: Optional[list[ts.ColumnType]] = None,
-    batch_size: Optional[int] = None,
-    substitute_fn: Optional[Callable] = None,
+    return_type: ts.ColumnType | None = None,
+    param_types: list[ts.ColumnType] | None = None,
+    batch_size: int | None = None,
+    substitute_fn: Callable | None = None,
     is_method: bool = False,
     is_property: bool = False,
-    resource_pool: Optional[str] = None,
-    type_substitutions: Optional[Sequence[dict]] = None,
-    function_name: Optional[str] = None,
+    resource_pool: str | None = None,
+    type_substitutions: Sequence[dict] | None = None,
+    function_name: str | None = None,
     force_stored: bool = False,
 ) -> CallableFunction:
     """
@@ -201,11 +201,11 @@ def expr_udf(py_fn: Callable) -> ExprTemplateFunction: ...
 
 
 @overload
-def expr_udf(*, param_types: Optional[list[ts.ColumnType]] = None) -> Callable[[Callable], ExprTemplateFunction]: ...
+def expr_udf(*, param_types: list[ts.ColumnType] | None = None) -> Callable[[Callable], ExprTemplateFunction]: ...
 
 
 def expr_udf(*args: Any, **kwargs: Any) -> Any:
-    def make_expr_template(py_fn: Callable, param_types: Optional[list[ts.ColumnType]]) -> ExprTemplateFunction:
+    def make_expr_template(py_fn: Callable, param_types: list[ts.ColumnType] | None) -> ExprTemplateFunction:
         from pixeltable import exprs
 
         if py_fn.__module__ != '__main__' and py_fn.__name__.isidentifier():
@@ -237,9 +237,7 @@ def expr_udf(*args: Any, **kwargs: Any) -> Any:
         return lambda py_fn: make_expr_template(py_fn, kwargs['param_types'])
 
 
-def from_table(
-    tbl: catalog.Table, return_value: Optional['exprs.Expr'], description: Optional[str]
-) -> ExprTemplateFunction:
+def from_table(tbl: catalog.Table, return_value: 'exprs.Expr' | None, description: str | None) -> ExprTemplateFunction:
     """
     Constructs an `ExprTemplateFunction` from a `Table`.
 
@@ -262,7 +260,7 @@ def from_table(
     """
     from pixeltable import exprs
 
-    ancestors = [tbl, *tbl._base_tables]
+    ancestors = [tbl, *tbl._get_base_tables()]
     ancestors.reverse()  # We must traverse the ancestors in order from base to derived
 
     subst: dict[exprs.Expr, exprs.Expr] = {}
@@ -297,7 +295,7 @@ def from_table(
 
     if description is None:
         # Default description is the table comment
-        description = tbl._comment
+        description = tbl._get_comment()
         if len(description) == 0:
             description = f"UDF for table '{tbl._name}'"
 

pixeltable/functions/__init__.py

@@ -1,3 +1,9 @@
+"""
+General Pixeltable UDFs.
+
+This parent module contains general-purpose UDFs that apply to multiple data types.
+"""
+
 # ruff: noqa: F401
 
 from pixeltable.utils.code import local_public_names
@@ -8,23 +14,33 @@ from . import (
     bedrock,
     date,
     deepseek,
+    fal,
     fireworks,
     gemini,
+    groq,
     huggingface,
     image,
     json,
     llama_cpp,
     math,
     mistralai,
+    net,
     ollama,
     openai,
+    openrouter,
     replicate,
+    reve,
     string,
     timestamp,
     together,
+    twelvelabs,
+    uuid,
     video,
     vision,
+    voyageai,
     whisper,
+    whisperx,
+    yolox,
 )
 from .globals import count, map, max, mean, min, sum