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

pixeltable/functions/image.py

@@ -11,7 +11,6 @@ t.select(t.img_col.convert('L')).collect()
 """
 
 import base64
-from typing import Optional
 
 import PIL.Image
 
@@ -156,7 +155,7 @@ def get_metadata(self: PIL.Image.Image) -> dict:
 
 # Image.point()
 @pxt.udf(is_method=True)
-def point(self: PIL.Image.Image, lut: list[int], mode: Optional[str] = None) -> PIL.Image.Image:
+def point(self: PIL.Image.Image, lut: list[int], mode: str | None = None) -> PIL.Image.Image:
     """
     Map image pixels through a lookup table.
 
@@ -241,7 +240,7 @@ def _(self: Expr) -> ts.ColumnType:
 
 
 @pxt.udf(substitute_fn=PIL.Image.Image.entropy, is_method=True)
-def entropy(self: PIL.Image.Image, mask: Optional[PIL.Image.Image] = None, extrema: Optional[list] = None) -> float:
+def entropy(self: PIL.Image.Image, mask: PIL.Image.Image | None = None, extrema: list | None = None) -> float:
     """
     Returns the entropy of the image, optionally using a mask and extrema.
 
@@ -306,7 +305,7 @@ def getextrema(self: PIL.Image.Image) -> tuple[int, int]:
 
 
 @pxt.udf(substitute_fn=PIL.Image.Image.getpalette, is_method=True)
-def getpalette(self: PIL.Image.Image, mode: Optional[str] = None) -> tuple[int]:
+def getpalette(self: PIL.Image.Image, mode: str | None = None) -> tuple[int]:
     """
     Return the palette of the image, optionally converting it to a different mode.
 
@@ -346,9 +345,7 @@ def getprojection(self: PIL.Image.Image) -> tuple[int]:
 
 
 @pxt.udf(substitute_fn=PIL.Image.Image.histogram, is_method=True)
-def histogram(
-    self: PIL.Image.Image, mask: Optional[PIL.Image.Image] = None, extrema: Optional[list] = None
-) -> list[int]:
+def histogram(self: PIL.Image.Image, mask: PIL.Image.Image | None = None, extrema: list | None = None) -> list[int]:
     """
     Return a histogram for the image.
 
@@ -366,9 +363,9 @@ def histogram(
 def quantize(
     self: PIL.Image.Image,
     colors: int = 256,
-    method: Optional[int] = None,
+    method: int | None = None,
     kmeans: int = 0,
-    palette: Optional[int] = None,
+    palette: int | None = None,
     dither: int = PIL.Image.Dither.FLOYDSTEINBERG,
 ) -> PIL.Image.Image:
     """
@@ -392,7 +389,7 @@ def quantize(
 
 
 @pxt.udf(substitute_fn=PIL.Image.Image.reduce, is_method=True)
-def reduce(self: PIL.Image.Image, factor: int, box: Optional[tuple[int, int, int, int]] = None) -> PIL.Image.Image:
+def reduce(self: PIL.Image.Image, factor: int, box: tuple[int, int, int, int] | None = None) -> PIL.Image.Image:
     """
     Reduce the image by the given factor.
 

pixeltable/functions/llama_cpp.py

@@ -6,7 +6,7 @@ supporting chat completions and embeddings with GGUF format models.
 """
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
@@ -21,10 +21,10 @@ if TYPE_CHECKING:
 def create_chat_completion(
     messages: list[dict],
     *,
-    model_path: Optional[str] = None,
-    repo_id: Optional[str] = None,
-    repo_filename: Optional[str] = None,
-    model_kwargs: Optional[dict[str, Any]] = None,
+    model_path: str | None = None,
+    repo_id: str | None = None,
+    repo_filename: str | None = None,
+    model_kwargs: dict[str, Any] | None = None,
 ) -> dict:
     """
     Generate a chat completion from a list of messages.
@@ -88,7 +88,7 @@ def _lookup_local_model(model_path: str, n_gpu_layers: int) -> 'llama_cpp.Llama'
     return _model_cache[key]
 
 
-def _lookup_pretrained_model(repo_id: str, filename: Optional[str], n_gpu_layers: int) -> 'llama_cpp.Llama':
+def _lookup_pretrained_model(repo_id: str, filename: str | None, n_gpu_layers: int) -> 'llama_cpp.Llama':
     import llama_cpp
 
     key = (repo_id, filename, n_gpu_layers)
@@ -101,7 +101,7 @@ def _lookup_pretrained_model(repo_id: str, filename: Optional[str], n_gpu_layers
 
 
 _model_cache: dict[tuple[str, str, int], 'llama_cpp.Llama'] = {}
-_IS_GPU_AVAILABLE: Optional[bool] = None
+_IS_GPU_AVAILABLE: bool | None = None
 
 
 def cleanup() -> None:

pixeltable/functions/math.py

@@ -12,7 +12,6 @@ t.select(t.float_col.floor()).collect()
 
 import builtins
 import math
-from typing import Optional
 
 import sqlalchemy as sql
 
@@ -80,7 +79,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
 
 
 @pxt.udf(is_method=True)
-def round(self: float, digits: Optional[int] = None) -> float:
+def round(self: float, digits: int | None = None) -> float:
     """
     Round a number to a given precision in decimal digits.
 
@@ -93,7 +92,7 @@ def round(self: float, digits: Optional[int] = None) -> float:
 
 
 @round.to_sql
-def _(self: sql.ColumnElement, digits: Optional[sql.ColumnElement] = None) -> sql.ColumnElement:
+def _(self: sql.ColumnElement, digits: sql.ColumnElement | None = None) -> sql.ColumnElement:
     if digits is None:
         return sql.func.round(self)
     else:

pixeltable/functions/mistralai.py

@@ -5,7 +5,7 @@ first `pip install mistralai` and configure your Mistral AI credentials, as desc
 the [Working with Mistral AI](https://pixeltable.readme.io/docs/working-with-mistralai) tutorial.
 """
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
@@ -32,7 +32,7 @@ def _mistralai_client() -> 'mistralai.Mistral':
 
 @pxt.udf(resource_pool='request-rate:mistral')
 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:
     """
     Chat Completion API.
@@ -77,7 +77,7 @@ async def chat_completions(
 
 
 @pxt.udf(resource_pool='request-rate:mistral')
-async def fim_completions(prompt: str, *, model: str, model_kwargs: Optional[dict[str, Any]] = None) -> dict:
+async def fim_completions(prompt: str, *, model: str, model_kwargs: dict[str, Any] | None = None) -> dict:
     """
     Fill-in-the-middle Completion API.
 

pixeltable/functions/ollama.py

@@ -5,7 +5,7 @@ Provides integration with Ollama for running large language models locally,
 including chat completions and embeddings.
 """
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -25,7 +25,7 @@ def _(host: str) -> 'ollama.Client':
     return ollama.Client(host=host)
 
 
-def _ollama_client() -> Optional['ollama.Client']:
+def _ollama_client() -> 'ollama.Client | None':
     try:
         return env.Env.get().get_client('ollama')
     except Exception:
@@ -40,10 +40,10 @@ def generate(
     suffix: str = '',
     system: str = '',
     template: str = '',
-    context: Optional[list[int]] = None,
+    context: list[int] | None = None,
     raw: bool = False,
-    format: Optional[str] = None,
-    options: Optional[dict] = None,
+    format: str | None = None,
+    options: dict | None = None,
 ) -> dict:
     """
     Generate a response for a given prompt with a provided model.
@@ -84,9 +84,9 @@ def chat(
     messages: list[dict],
     *,
     model: str,
-    tools: Optional[list[dict]] = None,
-    format: Optional[str] = None,
-    options: Optional[dict] = None,
+    tools: list[dict] | None = None,
+    format: str | None = None,
+    options: dict | None = None,
 ) -> dict:
     """
     Generate the next message in a chat with a provided model.
@@ -110,7 +110,7 @@ def chat(
 
 @pxt.udf(batch_size=16)
 def embed(
-    input: Batch[str], *, model: str, truncate: bool = True, options: Optional[dict] = None
+    input: Batch[str], *, model: str, truncate: bool = True, options: dict | None = None
 ) -> Batch[pxt.Array[(None,), pxt.Float]]:
     """
     Generate embeddings from a model.

pixeltable/functions/openai.py

@@ -13,7 +13,7 @@ import logging
 import math
 import pathlib
 import re
-from typing import TYPE_CHECKING, Any, Callable, Optional, Type
+from typing import TYPE_CHECKING, Any, Callable, Type
 
 import httpx
 import numpy as np
@@ -32,7 +32,7 @@ _logger = logging.getLogger('pixeltable')
 
 
 @env.register_client('openai')
-def _(api_key: str, base_url: Optional[str] = None, api_version: Optional[str] = None) -> 'openai.AsyncOpenAI':
+def _(api_key: str, base_url: str | None = None, api_version: str | None = None) -> 'openai.AsyncOpenAI':
     import openai
 
     default_query = None if api_version is None else {'api-version': api_version}
@@ -169,7 +169,7 @@ class OpenAIRateLimitsInfo(env.RateLimitsInfo):
         self.record(requests=requests_info, tokens=tokens_info)
         self.has_exc = True
 
-    def get_retry_delay(self, exc: Exception) -> Optional[float]:
+    def get_retry_delay(self, exc: Exception) -> float | None:
         import openai
 
         if not isinstance(exc, self.retryable_errors):
@@ -183,7 +183,7 @@ class OpenAIRateLimitsInfo(env.RateLimitsInfo):
 
 
 @pxt.udf
-async def speech(input: str, *, model: str, voice: str, model_kwargs: Optional[dict[str, Any]] = None) -> pxt.Audio:
+async def speech(input: str, *, model: str, voice: str, model_kwargs: dict[str, Any] | None = None) -> pxt.Audio:
     """
     Generates audio from the input text.
 
@@ -226,7 +226,7 @@ async def speech(input: str, *, model: str, voice: str, model_kwargs: Optional[d
 
 
 @pxt.udf
-async def transcriptions(audio: pxt.Audio, *, model: str, model_kwargs: Optional[dict[str, Any]] = None) -> dict:
+async def transcriptions(audio: pxt.Audio, *, model: str, model_kwargs: dict[str, Any] | None = None) -> dict:
     """
     Transcribes audio into the input language.
 
@@ -265,7 +265,7 @@ async def transcriptions(audio: pxt.Audio, *, model: str, model_kwargs: Optional
 
 
 @pxt.udf
-async def translations(audio: pxt.Audio, *, model: str, model_kwargs: Optional[dict[str, Any]] = None) -> dict:
+async def translations(audio: pxt.Audio, *, model: str, model_kwargs: dict[str, Any] | None = None) -> dict:
     """
     Translates audio into English.
 
@@ -335,7 +335,7 @@ def _is_model_family(model: str, family: str) -> bool:
 
 
 def _chat_completions_get_request_resources(
-    messages: list, model: str, model_kwargs: Optional[dict[str, Any]]
+    messages: list, model: str, model_kwargs: dict[str, Any] | None
 ) -> dict[str, int]:
     if model_kwargs is None:
         model_kwargs = {}
@@ -362,10 +362,10 @@ 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,
-    _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:
     """
     Creates a model response for the given chat conversation.
@@ -436,7 +436,7 @@ async def chat_completions(
 
 
 def _vision_get_request_resources(
-    prompt: str, image: PIL.Image.Image, model: str, model_kwargs: Optional[dict[str, Any]] = None
+    prompt: str, image: PIL.Image.Image, model: str, model_kwargs: dict[str, Any] | None = None
 ) -> dict[str, int]:
     if model_kwargs is None:
         model_kwargs = {}
@@ -477,8 +477,8 @@ async def vision(
     image: PIL.Image.Image,
     *,
     model: str,
-    model_kwargs: Optional[dict[str, Any]] = None,
-    _runtime_ctx: Optional[env.RuntimeCtx] = None,
+    model_kwargs: dict[str, Any] | None = None,
+    _runtime_ctx: env.RuntimeCtx | None = None,
 ) -> str:
     """
     Analyzes an image with the OpenAI vision capability. This is a convenience function that takes an image and
@@ -567,8 +567,8 @@ async def embeddings(
     input: Batch[str],
     *,
     model: str,
-    model_kwargs: Optional[dict[str, Any]] = None,
-    _runtime_ctx: Optional[env.RuntimeCtx] = None,
+    model_kwargs: dict[str, Any] | None = None,
+    _runtime_ctx: env.RuntimeCtx | None = None,
 ) -> Batch[pxt.Array[(None,), pxt.Float]]:
     """
     Creates an embedding vector representing the input text.
@@ -621,8 +621,8 @@ async def embeddings(
 
 
 @embeddings.conditional_return_type
-def _(model: str, model_kwargs: Optional[dict[str, Any]] = None) -> ts.ArrayType:
-    dimensions: Optional[int] = None
+def _(model: str, model_kwargs: dict[str, Any] | None = None) -> ts.ArrayType:
+    dimensions: int | None = None
     if model_kwargs is not None:
         dimensions = model_kwargs.get('dimensions')
     if dimensions is None:
@@ -639,7 +639,7 @@ def _(model: str, model_kwargs: Optional[dict[str, Any]] = None) -> ts.ArrayType
 
 @pxt.udf
 async def image_generations(
-    prompt: str, *, model: str = 'dall-e-2', model_kwargs: Optional[dict[str, Any]] = None
+    prompt: str, *, model: str = 'dall-e-2', model_kwargs: dict[str, Any] | None = None
 ) -> PIL.Image.Image:
     """
     Creates an image given a prompt.
@@ -685,7 +685,7 @@ async def image_generations(
 
 
 @image_generations.conditional_return_type
-def _(model_kwargs: Optional[dict[str, Any]] = None) -> ts.ImageType:
+def _(model_kwargs: dict[str, Any] | None = None) -> ts.ImageType:
     if model_kwargs is None or 'size' not in model_kwargs:
         # default size is 1024x1024
         return ts.ImageType(size=(1024, 1024))
@@ -761,7 +761,7 @@ def invoke_tools(tools: Tools, response: exprs.Expr) -> exprs.InlineDict:
 
 
 @pxt.udf
-def _openai_response_to_pxt_tool_calls(response: dict) -> Optional[dict]:
+def _openai_response_to_pxt_tool_calls(response: dict) -> dict | None:
     if 'tool_calls' not in response['choices'][0]['message'] or response['choices'][0]['message']['tool_calls'] is None:
         return None
     openai_tool_calls = response['choices'][0]['message']['tool_calls']

pixeltable/functions/openrouter.py

@@ -6,7 +6,7 @@ you must first sign up at https://openrouter.ai, create an API key, and configur
 as described in the Working with OpenRouter tutorial.
 """
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import pixeltable as pxt
 from pixeltable.env import Env, register_client
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 
 
 @register_client('openrouter')
-def _(api_key: str, site_url: Optional[str] = None, app_name: Optional[str] = None) -> 'openai.AsyncOpenAI':
+def _(api_key: str, site_url: str | None = None, app_name: str | None = None) -> 'openai.AsyncOpenAI':
     import openai
 
     # Create default headers for OpenRouter
@@ -39,11 +39,11 @@ 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,
-    provider: Optional[dict[str, Any]] = None,
-    transforms: Optional[list[str]] = None,
+    model_kwargs: dict[str, Any] | None = None,
+    tools: list[dict[str, Any]] | None = None,
+    tool_choice: dict[str, Any] | None = None,
+    provider: dict[str, Any] | None = None,
+    transforms: list[str] | None = None,
 ) -> dict:
     """
     Chat Completion API via OpenRouter.

pixeltable/functions/string.py

@@ -15,7 +15,7 @@ import builtins
 import re
 import textwrap
 from string import whitespace
-from typing import Any, Optional
+from typing import Any
 
 import sqlalchemy as sql
 
@@ -78,9 +78,7 @@ def contains(self: str, substr: str, case: bool = True) -> bool:
 
 
 @contains.to_sql
-def _(
-    self: sql.ColumnElement, substr: sql.ColumnElement, case: Optional[sql.ColumnElement] = None
-) -> sql.ColumnElement:
+def _(self: sql.ColumnElement, substr: sql.ColumnElement, case: sql.ColumnElement | None = None) -> sql.ColumnElement:
     # Replace all occurrences of `%`, `_`, and `\` with escaped versions
     escaped_substr = sql.func.regexp_replace(substr, r'(%|_|\\)', r'\\\1', 'g')
     if case is None:
@@ -153,7 +151,7 @@ def fill(self: str, width: int, **kwargs: Any) -> str:
 
 
 @pxt.udf(is_method=True)
-def find(self: str, substr: str, start: int = 0, end: Optional[int] = None) -> int:
+def find(self: str, substr: str, start: int = 0, end: int | None = None) -> int:
     """
     Return the lowest index in string where `substr` is found within the slice `s[start:end]`.
 
@@ -169,10 +167,7 @@ def find(self: str, substr: str, start: int = 0, end: Optional[int] = None) -> i
 
 @find.to_sql
 def _(
-    self: sql.ColumnElement,
-    substr: sql.ColumnElement,
-    start: sql.ColumnElement,
-    end: Optional[sql.ColumnElement] = None,
+    self: sql.ColumnElement, substr: sql.ColumnElement, start: sql.ColumnElement, end: sql.ColumnElement | None = None
 ) -> sql.ColumnElement:
     sl = pxt.functions.string.slice._to_sql(self, start, end)
     if sl is None:
@@ -227,7 +222,7 @@ def fullmatch(self: str, pattern: str, case: bool = True, flags: int = 0) -> boo
 
 
 @pxt.udf(is_method=True)
-def index(self: str, substr: str, start: int = 0, end: Optional[int] = None) -> int:
+def index(self: str, substr: str, start: int = 0, end: int | None = None) -> int:
     """
     Return the lowest index in string where `substr` is found within the slice `[start:end]`.
     Raises ValueError if `substr` is not found.
@@ -413,7 +408,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
 
 
 @pxt.udf(is_method=True)
-def lstrip(self: str, chars: Optional[str] = None) -> str:
+def lstrip(self: str, chars: str | None = None) -> str:
     """
     Return a copy of the string with leading characters removed. The `chars` argument is a string specifying the set of
     characters to be removed. If omitted or `None`, whitespace characters are removed.
@@ -427,7 +422,7 @@ def lstrip(self: str, chars: Optional[str] = None) -> str:
 
 
 @lstrip.to_sql
-def _(self: sql.ColumnElement, chars: Optional[sql.ColumnElement] = None) -> sql.ColumnElement:
+def _(self: sql.ColumnElement, chars: sql.ColumnElement | None = None) -> sql.ColumnElement:
     return sql.func.ltrim(self, chars if chars is not None else whitespace)
 
 
@@ -535,7 +530,7 @@ def _(self: sql.ColumnElement, n: sql.ColumnElement) -> sql.ColumnElement:
 
 
 @pxt.udf(is_method=True)
-def replace(self: str, substr: str, repl: str, n: Optional[int] = None) -> str:
+def replace(self: str, substr: str, repl: str, n: int | None = None) -> str:
     """
     Replace occurrences of `substr` with `repl`.
 
@@ -551,7 +546,7 @@ def replace(self: str, substr: str, repl: str, n: Optional[int] = None) -> str:
 
 @replace.to_sql
 def _(
-    self: sql.ColumnElement, substr: sql.ColumnElement, repl: sql.ColumnElement, n: Optional[sql.ColumnElement] = None
+    self: sql.ColumnElement, substr: sql.ColumnElement, repl: sql.ColumnElement, n: sql.ColumnElement | None = None
 ) -> sql.ColumnElement:
     if n is not None:
         return None  # SQL does not support bounding the number of replacements
@@ -560,7 +555,7 @@ def _(
 
 
 @pxt.udf(is_method=True)
-def replace_re(self: str, pattern: str, repl: str, n: Optional[int] = None, flags: int = 0) -> str:
+def replace_re(self: str, pattern: str, repl: str, n: int | None = None, flags: int = 0) -> str:
     """
     Replace occurrences of a regular expression pattern with `repl`.
 
@@ -591,7 +586,7 @@ def _(self: sql.ColumnElement) -> sql.ColumnElement:
 
 
 @pxt.udf(is_method=True)
-def rfind(self: str, substr: str, start: Optional[int] = 0, end: Optional[int] = None) -> int:
+def rfind(self: str, substr: str, start: int | None = 0, end: int | None = None) -> int:
     """
     Return the highest index where `substr` is found, such that `substr` is contained within `[start:end]`.
 
@@ -606,7 +601,7 @@ def rfind(self: str, substr: str, start: Optional[int] = 0, end: Optional[int] =
 
 
 @pxt.udf(is_method=True)
-def rindex(self: str, substr: str, start: Optional[int] = 0, end: Optional[int] = None) -> int:
+def rindex(self: str, substr: str, start: int | None = 0, end: int | None = None) -> int:
     """
     Return the highest index where `substr` is found, such that `substr` is contained within `[start:end]`.
     Raises ValueError if `substr` is not found.
@@ -643,7 +638,7 @@ def rpartition(self: str, sep: str = ' ') -> list:
 
 
 @pxt.udf(is_method=True)
-def rstrip(self: str, chars: Optional[str] = None) -> str:
+def rstrip(self: str, chars: str | None = None) -> str:
     """
     Return a copy of string with trailing characters removed.
 
@@ -656,12 +651,12 @@ def rstrip(self: str, chars: Optional[str] = None) -> str:
 
 
 @rstrip.to_sql
-def _(self: sql.ColumnElement, chars: Optional[sql.ColumnElement] = None) -> sql.ColumnElement:
+def _(self: sql.ColumnElement, chars: sql.ColumnElement | None = None) -> sql.ColumnElement:
     return sql.func.rtrim(self, chars if chars is not None else whitespace)
 
 
 @pxt.udf(is_method=True)
-def slice(self: str, start: Optional[int] = None, stop: Optional[int] = None, step: Optional[int] = None) -> str:
+def slice(self: str, start: int | None = None, stop: int | None = None, step: int | None = None) -> str:
     """
     Return a slice.
 
@@ -676,9 +671,9 @@ def slice(self: str, start: Optional[int] = None, stop: Optional[int] = None, st
 @slice.to_sql
 def _(
     self: sql.ColumnElement,
-    start: Optional[sql.ColumnElement] = None,
-    stop: Optional[sql.ColumnElement] = None,
-    step: Optional[sql.ColumnElement] = None,
+    start: sql.ColumnElement | None = None,
+    stop: sql.ColumnElement | None = None,
+    step: sql.ColumnElement | None = None,
 ) -> sql.ColumnElement:
     if step is not None:
         return None
@@ -709,9 +704,7 @@ def _(
 
 
 @pxt.udf(is_method=True)
-def slice_replace(
-    self: str, start: Optional[int] = None, stop: Optional[int] = None, repl: Optional[str] = None
-) -> str:
+def slice_replace(self: str, start: int | None = None, stop: int | None = None, repl: str | None = None) -> str:
     """
     Replace a positional slice with another value.
 
@@ -744,7 +737,7 @@ def _(self: sql.ColumnElement, substr: sql.ColumnElement) -> sql.ColumnElement:
 
 
 @pxt.udf(is_method=True)
-def strip(self: str, chars: Optional[str] = None) -> str:
+def strip(self: str, chars: str | None = None) -> str:
     """
     Return a copy of string with leading and trailing characters removed.
 
@@ -757,7 +750,7 @@ def strip(self: str, chars: Optional[str] = None) -> str:
 
 
 @strip.to_sql
-def _(self: sql.ColumnElement, chars: Optional[sql.ColumnElement] = None) -> sql.ColumnElement:
+def _(self: sql.ColumnElement, chars: sql.ColumnElement | None = None) -> sql.ColumnElement:
     return sql.func.trim(self, chars if chars is not None else whitespace)
 
 

pixeltable/functions/timestamp.py

@@ -11,7 +11,6 @@ t.select(t.timestamp_col.year, t.timestamp_col.weekday()).collect()
 """
 
 from datetime import datetime
-from typing import Optional
 
 import sqlalchemy as sql
 
@@ -271,13 +270,13 @@ def _(
 @pxt.udf(is_method=True)
 def replace(
     self: datetime,
-    year: Optional[int] = None,
-    month: Optional[int] = None,
-    day: Optional[int] = None,
-    hour: Optional[int] = None,
-    minute: Optional[int] = None,
-    second: Optional[int] = None,
-    microsecond: Optional[int] = None,
+    year: int | None = None,
+    month: int | None = None,
+    day: int | None = None,
+    hour: int | None = None,
+    minute: int | None = None,
+    second: int | None = None,
+    microsecond: int | None = None,
 ) -> datetime:
     """
     Return a datetime with the same attributes, except for those attributes given new values by whichever keyword

pixeltable/functions/together.py

@@ -7,7 +7,7 @@ the [Working with Together AI](https://pixeltable.readme.io/docs/together-ai) tu
 
 import base64
 import io
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
 
 import numpy as np
 import PIL.Image
@@ -50,7 +50,7 @@ def _retry(fn: Callable[..., T]) -> Callable[..., T]:
 
 
 @pxt.udf(resource_pool='request-rate:together:chat')
-async def completions(prompt: str, *, model: str, model_kwargs: Optional[dict[str, Any]] = None) -> dict:
+async def completions(prompt: str, *, model: str, model_kwargs: dict[str, Any] | None = None) -> dict:
     """
     Generate completions based on a given prompt using a specified model.
 
@@ -89,7 +89,7 @@ async def completions(prompt: str, *, model: str, model_kwargs: Optional[dict[st
 
 @pxt.udf(resource_pool='request-rate:together:chat')
 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:
     """
     Generate chat completions based on a given prompt using a specified model.
@@ -183,9 +183,7 @@ def _(model: str) -> ts.ArrayType:
 
 
 @pxt.udf(resource_pool='request-rate:together:images')
-async def image_generations(
-    prompt: str, *, model: str, model_kwargs: Optional[dict[str, Any]] = None
-) -> PIL.Image.Image:
+async def image_generations(prompt: str, *, model: str, model_kwargs: dict[str, Any] | None = None) -> PIL.Image.Image:
     """
     Generate images based on a given prompt using a specified model.