pixeltable 0.4.18__py3-none-any.whl → 0.4.19__py3-none-any.whl

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:
@@ -104,7 +104,7 @@ class Signature:
         return_type: ts.ColumnType,
         parameters: list[Parameter],
         is_batched: bool = False,
-        system_parameters: Optional[list[str]] = None,
+        system_parameters: list[str] | None = None,
     ):
         assert isinstance(return_type, ts.ColumnType)
         self.return_type = return_type
@@ -172,7 +172,7 @@ 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})'
 
@@ -231,11 +231,11 @@ class Signature:
         return f'({", ".join(param_strs)}) -> {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)
@@ -252,10 +252,10 @@ 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 '_'."""
@@ -310,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.

pixeltable/func/tools.py

@@ -1,5 +1,5 @@
 import json
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
 
 import pydantic
 
@@ -29,8 +29,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]:
@@ -78,7 +78,7 @@ class Tool(pydantic.BaseModel):
 class ToolChoice(pydantic.BaseModel):
     auto: bool
     required: bool
-    tool: Optional[str]
+    tool: str | None
     parallel_tool_calls: bool
 
 
@@ -105,7 +105,7 @@ class Tools(pydantic.BaseModel):
     ) -> 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(
@@ -121,27 +121,27 @@ 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) -> Optional[ts.Json]:
+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
@@ -150,7 +150,7 @@ def _extract_json_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[
 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`.
 

pixeltable/functions/__init__.py

@@ -24,6 +24,7 @@ from . import (
     string,
     timestamp,
     together,
+    twelvelabs,
     video,
     vision,
     whisper,

pixeltable/functions/anthropic.py

@@ -8,7 +8,7 @@ the [Working with Anthropic](https://pixeltable.readme.io/docs/working-with-anth
 import datetime
 import json
 import logging
-from typing import TYPE_CHECKING, Any, Iterable, Optional, cast
+from typing import TYPE_CHECKING, Any, Iterable, cast
 
 import httpx
 
@@ -130,7 +130,7 @@ class AnthropicRateLimitsInfo(env.RateLimitsInfo):
         if retry_after_str is not None:
             _logger.debug(f'retry-after: {retry_after_str}')
 
-    def get_retry_delay(self, exc: Exception) -> Optional[float]:
+    def get_retry_delay(self, exc: Exception) -> float | None:
         import anthropic
 
         # deal with timeouts separately, they don't come with headers
@@ -152,10 +152,10 @@ async def messages(
     *,
     model: str,
     max_tokens: int,
-    model_kwargs: Optional[dict[str, Any]] = None,
-    tools: Optional[list[dict[str, Any]]] = None,
-    tool_choice: Optional[dict[str, Any]] = None,
-    _runtime_ctx: Optional[env.RuntimeCtx] = None,
+    model_kwargs: dict[str, Any] | None = None,
+    tools: list[dict[str, Any]] | None = None,
+    tool_choice: dict[str, Any] | None = None,
+    _runtime_ctx: env.RuntimeCtx | None = None,
 ) -> dict:
     """
     Create a Message.
@@ -254,7 +254,7 @@ def invoke_tools(tools: Tools, response: exprs.Expr) -> exprs.InlineDict:
 
 
 @pxt.udf
-def _anthropic_response_to_pxt_tool_calls(response: dict) -> Optional[dict]:
+def _anthropic_response_to_pxt_tool_calls(response: dict) -> dict | None:
     anthropic_tool_calls = [r for r in response['content'] if r['type'] == 'tool_use']
     if len(anthropic_tool_calls) == 0:
         return None

pixeltable/functions/audio.py

@@ -2,9 +2,13 @@
 Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for `AudioType`.
 """
 
+import av
+import numpy as np
+
 import pixeltable as pxt
 import pixeltable.utils.av as av_utils
 from pixeltable.utils.code import local_public_names
+from pixeltable.utils.local_store import TempStore
 
 
 @pxt.udf(is_method=True)
@@ -51,6 +55,78 @@ def get_metadata(audio: pxt.Audio) -> dict:
     return av_utils.get_metadata(audio)
 
 
+@pxt.udf()
+def encode_audio(
+    audio_data: pxt.Array[pxt.Float], *, input_sample_rate: int, format: str, output_sample_rate: int | None = None
+) -> pxt.Audio:
+    """
+    Encodes an audio clip represented as an array into a specified audio format.
+
+    Parameters:
+        audio_data: An array of sampled amplitudes. The accepted array shapes are `(N,)` or `(1, N)` for mono audio
+            or `(2, N)` for stereo.
+        input_sample_rate: The sample rate of the input audio data.
+        format: The desired output audio format. The supported formats are 'wav', 'mp3', 'flac', and 'mp4'.
+        output_sample_rate: The desired sample rate for the output audio. Defaults to the input sample rate if
+            unspecified.
+
+    Examples:
+        Add a computed column with encoded FLAC audio files to a table with audio data (as arrays of floats) and sample
+        rates:
+
+        ```
+        t.add_computed_column(
+            audio_file=encode_audio(
+                t.audio_data, input_sample_rate=t.sample_rate, format='flac'
+            )
+        )
+        ```
+    """
+    if format not in av_utils.AUDIO_FORMATS:
+        raise pxt.Error(f'Only the following formats are supported: {av_utils.AUDIO_FORMATS.keys()}')
+    if output_sample_rate is None:
+        output_sample_rate = input_sample_rate
+
+    codec, ext = av_utils.AUDIO_FORMATS[format]
+    output_path = str(TempStore.create_path(extension=f'.{ext}'))
+
+    match audio_data.shape:
+        case (_,):
+            # Mono audio as 1D array, reshape for pyav
+            layout = 'mono'
+            audio_data_transformed = audio_data[None, :]
+        case (1, _):
+            # Mono audio as 2D array, simply reshape and transpose the input for pyav
+            layout = 'mono'
+            audio_data_transformed = audio_data.reshape(-1, 1).transpose()
+        case (2, _):
+            # Stereo audio. Input layout: [[L0, L1, L2, ...],[R0, R1, R2, ...]],
+            # pyav expects: [L0, R0, L1, R1, L2, R2, ...]
+            layout = 'stereo'
+            audio_data_transformed = np.empty(audio_data.shape[1] * 2, dtype=audio_data.dtype)
+            audio_data_transformed[0::2] = audio_data[0]
+            audio_data_transformed[1::2] = audio_data[1]
+            audio_data_transformed = audio_data_transformed.reshape(1, -1)
+        case _:
+            raise pxt.Error(
+                f'Supported input array shapes are (N,), (1, N) for mono and (2, N) for stereo, got {audio_data.shape}'
+            )
+
+    with av.open(output_path, mode='w') as output_container:
+        stream = output_container.add_stream(codec, rate=output_sample_rate)
+        assert isinstance(stream, av.AudioStream)
+
+        frame = av.AudioFrame.from_ndarray(audio_data_transformed, format='flt', layout=layout)
+        frame.sample_rate = input_sample_rate
+
+        for packet in stream.encode(frame):
+            output_container.mux(packet)
+        for packet in stream.encode():
+            output_container.mux(packet)
+
+        return output_path
+
+
 __all__ = local_public_names(__name__)
 
 

pixeltable/functions/bedrock.py

@@ -6,7 +6,7 @@ including Anthropic Claude, Amazon Titan, and other providers.
 """
 
 import logging
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import pixeltable as pxt
 from pixeltable import env, exprs
@@ -36,10 +36,10 @@ def converse(
     messages: list[dict[str, Any]],
     *,
     model_id: str,
-    system: Optional[list[dict[str, Any]]] = None,
-    inference_config: Optional[dict] = None,
-    additional_model_request_fields: Optional[dict] = None,
-    tool_config: Optional[list[dict]] = None,
+    system: list[dict[str, Any]] | None = None,
+    inference_config: dict | None = None,
+    additional_model_request_fields: dict | None = None,
+    tool_config: list[dict] | None = None,
 ) -> dict:
     """
     Generate a conversation response.
@@ -111,7 +111,7 @@ def invoke_tools(tools: Tools, response: exprs.Expr) -> exprs.InlineDict:
 
 
 @pxt.udf
-def _bedrock_response_to_pxt_tool_calls(response: dict) -> Optional[dict]:
+def _bedrock_response_to_pxt_tool_calls(response: dict) -> dict | None:
     if response.get('stopReason') != 'tool_use':
         return None
 

pixeltable/functions/deepseek.py

@@ -6,7 +6,7 @@ and other AI capabilities.
 """
 
 import json
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import httpx
 
@@ -38,9 +38,9 @@ async def chat_completions(
     messages: list,
     *,
     model: str,
-    model_kwargs: Optional[dict[str, Any]] = None,
-    tools: Optional[list[dict[str, Any]]] = None,
-    tool_choice: Optional[dict[str, Any]] = None,
+    model_kwargs: dict[str, Any] | None = None,
+    tools: list[dict[str, Any]] | None = None,
+    tool_choice: dict[str, Any] | None = None,
 ) -> dict:
     """
     Creates a model response for the given chat conversation.

pixeltable/functions/fireworks.py

@@ -5,7 +5,7 @@ first `pip install fireworks-ai` and configure your Fireworks AI credentials, as
 the [Working with Fireworks](https://pixeltable.readme.io/docs/working-with-fireworks) tutorial.
 """
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import pixeltable as pxt
 from pixeltable import env
@@ -29,7 +29,7 @@ def _fireworks_client() -> 'fireworks.client.Fireworks':
 
 @pxt.udf(resource_pool='request-rate:fireworks')
 async def chat_completions(
-    messages: list[dict[str, str]], *, model: str, model_kwargs: Optional[dict[str, Any]] = None
+    messages: list[dict[str, str]], *, model: str, model_kwargs: dict[str, Any] | None = None
 ) -> dict:
     """
     Creates a model response for the given chat conversation.

pixeltable/functions/gemini.py

@@ -8,7 +8,7 @@ the [Working with Gemini](https://pixeltable.readme.io/docs/working-with-gemini)
 import asyncio
 import io
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import PIL.Image
 
@@ -34,7 +34,7 @@ def _genai_client() -> 'genai.client.Client':
 
 @pxt.udf(resource_pool='request-rate:gemini')
 async def generate_content(
-    contents: str, *, model: str, config: Optional[dict] = None, tools: Optional[list[dict]] = None
+    contents: str, *, model: str, config: dict | None = None, tools: list[dict] | None = None
 ) -> dict:
     """
     Generate content from the specified model. For additional details, see:
@@ -103,7 +103,7 @@ def invoke_tools(tools: pxt.func.Tools, response: exprs.Expr) -> exprs.InlineDic
 
 
 @pxt.udf
-def _gemini_response_to_pxt_tool_calls(response: dict) -> Optional[dict]:
+def _gemini_response_to_pxt_tool_calls(response: dict) -> dict | None:
     pxt_tool_calls: dict[str, list[dict]] = {}
     for part in response['candidates'][0]['content']['parts']:
         tool_call = part.get('function_call')
@@ -123,7 +123,7 @@ def _(model: str) -> str:
 
 
 @pxt.udf(resource_pool='request-rate:imagen')
-async def generate_images(prompt: str, *, model: str, config: Optional[dict] = None) -> PIL.Image.Image:
+async def generate_images(prompt: str, *, model: str, config: dict | None = None) -> PIL.Image.Image:
     """
     Generates images based on a text description and configuration. For additional details, see:
     <https://ai.google.dev/gemini-api/docs/image-generation>
@@ -167,7 +167,7 @@ def _(model: str) -> str:
 
 @pxt.udf(resource_pool='request-rate:veo')
 async def generate_videos(
-    prompt: Optional[str] = None, image: Optional[PIL.Image.Image] = None, *, model: str, config: Optional[dict] = None
+    prompt: str | None = None, image: PIL.Image.Image | None = None, *, model: str, config: dict | None = None
 ) -> pxt.Video:
     """
     Generates videos based on a text description and configuration. For additional details, see:
@@ -205,7 +205,7 @@ async def generate_videos(
     if prompt is None and image is None:
         raise excs.Error('At least one of `prompt` or `image` must be provided.')
 
-    image_: Optional[types.Image] = None
+    image_: types.Image | None = None
     if image is not None:
         with io.BytesIO() as buffer:
             image.save(buffer, format='jpeg')

pixeltable/functions/globals.py

@@ -1,6 +1,6 @@
 import builtins
 import typing
-from typing import Any, Callable, Optional
+from typing import Any, Callable
 
 import sqlalchemy as sql
 
@@ -19,7 +19,7 @@ def cast(expr: exprs.Expr, target_type: ts.ColumnType | type | _GenericAlias) ->
 T = typing.TypeVar('T')
 
 
-@func.uda(allows_window=True, type_substitutions=({T: Optional[int]}, {T: Optional[float]}))  # type: ignore[misc]
+@func.uda(allows_window=True, type_substitutions=({T: int | None}, {T: float | None}))  # type: ignore[misc]
 class sum(func.Aggregator, typing.Generic[T]):
     """Sums the selected integers or floats."""
 
@@ -39,7 +39,7 @@ class sum(func.Aggregator, typing.Generic[T]):
 
 
 @sum.to_sql
-def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+def _(val: sql.ColumnElement) -> sql.ColumnElement | None:
     # This can produce a Decimal. We are deliberately avoiding an explicit cast to a Bigint here, because that can
     # cause overflows in Postgres. We're instead doing the conversion to the target type in SqlNode.__iter__().
     return sql.sql.func.sum(val)
@@ -49,7 +49,7 @@ def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
     allows_window=True,
     # Allow counting non-null values of any type
     # TODO: should we have an "Any" type that can be used here?
-    type_substitutions=tuple({T: Optional[t]} for t in ts.ALL_PIXELTABLE_TYPES),  # type: ignore[misc]
+    type_substitutions=tuple({T: t | None} for t in ts.ALL_PIXELTABLE_TYPES),  # type: ignore[misc]
 )
 class count(func.Aggregator, typing.Generic[T]):
     def __init__(self) -> None:
@@ -64,13 +64,13 @@ class count(func.Aggregator, typing.Generic[T]):
 
 
 @count.to_sql
-def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+def _(val: sql.ColumnElement) -> sql.ColumnElement | None:
     return sql.sql.func.count(val)
 
 
 @func.uda(
     allows_window=True,
-    type_substitutions=tuple({T: Optional[t]} for t in (str, int, float, bool, ts.Timestamp)),  # type: ignore[misc]
+    type_substitutions=tuple({T: t | None} for t in (str, int, float, bool, ts.Timestamp)),  # type: ignore[misc]
 )
 class min(func.Aggregator, typing.Generic[T]):
     def __init__(self) -> None:
@@ -89,7 +89,7 @@ class min(func.Aggregator, typing.Generic[T]):
 
 
 @min.to_sql
-def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+def _(val: sql.ColumnElement) -> sql.ColumnElement | None:
     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
@@ -100,7 +100,7 @@ def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
 
 @func.uda(
     allows_window=True,
-    type_substitutions=tuple({T: Optional[t]} for t in (str, int, float, bool, ts.Timestamp)),  # type: ignore[misc]
+    type_substitutions=tuple({T: t | None} for t in (str, int, float, bool, ts.Timestamp)),  # type: ignore[misc]
 )
 class max(func.Aggregator, typing.Generic[T]):
     def __init__(self) -> None:
@@ -119,14 +119,14 @@ class max(func.Aggregator, typing.Generic[T]):
 
 
 @max.to_sql
-def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+def _(val: sql.ColumnElement) -> sql.ColumnElement | None:
     if val.type.python_type is bool:
         # TODO: see comment in @min.to_sql.
         return None
     return sql.sql.func.max(val)
 
 
-@func.uda(type_substitutions=({T: Optional[int]}, {T: Optional[float]}))  # type: ignore[misc]
+@func.uda(type_substitutions=({T: int | None}, {T: float | None}))  # type: ignore[misc]
 class mean(func.Aggregator, typing.Generic[T]):
     def __init__(self) -> None:
         self.sum: T = None
@@ -141,14 +141,14 @@ class mean(func.Aggregator, typing.Generic[T]):
             self.sum += val  # type: ignore[operator]
         self.count += 1
 
-    def value(self) -> Optional[float]:  # Always a float
+    def value(self) -> float | None:  # Always a float
         if self.count == 0:
             return None
         return self.sum / self.count  # type: ignore[operator]
 
 
 @mean.to_sql
-def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+def _(val: sql.ColumnElement) -> sql.ColumnElement | None:
     return sql.sql.func.avg(val)
 
 

pixeltable/functions/groq.py

@@ -5,7 +5,7 @@ first `pip install groq` and configure your Groq credentials, as described in
 the [Working with Groq](https://pixeltable.readme.io/docs/working-with-groq) tutorial.
 """
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import pixeltable as pxt
 from pixeltable import exprs
@@ -34,9 +34,9 @@ async def chat_completions(
     messages: list[dict[str, str]],
     *,
     model: str,
-    model_kwargs: Optional[dict[str, Any]] = None,
-    tools: Optional[list[dict[str, Any]]] = None,
-    tool_choice: Optional[dict[str, Any]] = None,
+    model_kwargs: dict[str, Any] | None = None,
+    tools: list[dict[str, Any]] | None = None,
+    tool_choice: dict[str, Any] | None = None,
 ) -> dict:
     """
     Chat Completion API.