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

pixeltable/functions/huggingface.py

@@ -7,7 +7,7 @@ first `pip install transformers` (or in some cases, `sentence-transformers`, as
 UDFs).
 """
 
-from typing import Any, Callable, Literal, Optional, TypeVar
+from typing import Any, Callable, Literal, TypeVar
 
 import av
 import numpy as np
@@ -351,7 +351,7 @@ def vit_for_image_classification(
 
 
 @pxt.udf
-def speech2text_for_conditional_generation(audio: pxt.Audio, *, model_id: str, language: Optional[str] = None) -> str:
+def speech2text_for_conditional_generation(audio: pxt.Audio, *, model_id: str, language: str | None = None) -> str:
     """
     Transcribes or translates speech to text using a Speech2Text model. `model_id` should be a reference to a
     pretrained [Speech2Text](https://huggingface.co/docs/transformers/en/model_doc/speech_to_text) model.
@@ -408,7 +408,7 @@ def speech2text_for_conditional_generation(audio: pxt.Audio, *, model_id: str, l
             f'Supported languages are: {list(tokenizer.lang_code_to_id.keys())}'
         )
 
-    forced_bos_token_id: Optional[int] = None if language is None else tokenizer.lang_code_to_id[language]
+    forced_bos_token_id: int | None = None if language is None else tokenizer.lang_code_to_id[language]
 
     # Get the model's sampling rate. Default to 16 kHz (the standard) if not in config
     model_sampling_rate = getattr(model.config, 'sampling_rate', 16_000)
@@ -460,7 +460,7 @@ def detr_to_coco(image: PIL.Image.Image, detr_info: dict[str, Any]) -> dict[str,
 
 
 @pxt.udf
-def text_generation(text: str, *, model_id: str, model_kwargs: Optional[dict[str, Any]] = None) -> str:
+def text_generation(text: str, *, model_id: str, model_kwargs: dict[str, Any] | None = None) -> str:
     """
     Generates text using a pretrained language model. `model_id` should be a reference to a pretrained
     [text generation model](https://huggingface.co/models?pipeline_tag=text-generation).
@@ -574,7 +574,7 @@ def text_classification(text: Batch[str], *, model_id: str, top_k: int = 5) -> B
 
 @pxt.udf(batch_size=4)
 def image_captioning(
-    image: Batch[PIL.Image.Image], *, model_id: str, model_kwargs: Optional[dict[str, Any]] = None
+    image: Batch[PIL.Image.Image], *, model_id: str, model_kwargs: dict[str, Any] | None = None
 ) -> Batch[str]:
     """
     Generates captions for images using a pretrained image captioning model. `model_id` should be a reference to a
@@ -624,7 +624,7 @@ def image_captioning(
 
 
 @pxt.udf(batch_size=8)
-def summarization(text: Batch[str], *, model_id: str, model_kwargs: Optional[dict[str, Any]] = None) -> Batch[str]:
+def summarization(text: Batch[str], *, model_id: str, model_kwargs: dict[str, Any] | None = None) -> Batch[str]:
     """
     Summarizes text using a pretrained summarization model. `model_id` should be a reference to a pretrained
     [summarization model](https://huggingface.co/models?pipeline_tag=summarization) such as BART, T5, or Pegasus.
@@ -880,7 +880,7 @@ def question_answering(context: str, question: str, *, model_id: str) -> dict[st
 
 @pxt.udf(batch_size=8)
 def translation(
-    text: Batch[str], *, model_id: str, src_lang: Optional[str] = None, target_lang: Optional[str] = None
+    text: Batch[str], *, model_id: str, src_lang: str | None = None, target_lang: str | None = None
 ) -> Batch[str]:
     """
     Translates text using a pretrained translation model. `model_id` should be a reference to a pretrained
@@ -954,8 +954,8 @@ def text_to_image(
     model_id: str,
     height: int = 512,
     width: int = 512,
-    seed: Optional[int] = None,
-    model_kwargs: Optional[dict[str, Any]] = None,
+    seed: int | None = None,
+    model_kwargs: dict[str, Any] | None = None,
 ) -> PIL.Image.Image:
     """
     Generates images from text prompts using a pretrained text-to-image model. `model_id` should be a reference to a
@@ -1034,9 +1034,7 @@ def text_to_image(
 
 
 @pxt.udf
-def text_to_speech(
-    text: str, *, model_id: str, speaker_id: Optional[int] = None, vocoder: Optional[str] = None
-) -> pxt.Audio:
+def text_to_speech(text: str, *, model_id: str, speaker_id: int | None = None, vocoder: str | None = None) -> pxt.Audio:
     """
     Converts text to speech using a pretrained TTS model. `model_id` should be a reference to a
     pretrained [text-to-speech model](https://huggingface.co/models?pipeline_tag=text-to-speech).
@@ -1142,8 +1140,8 @@ def image_to_image(
     prompt: str,
     *,
     model_id: str,
-    seed: Optional[int] = None,
-    model_kwargs: Optional[dict[str, Any]] = None,
+    seed: int | None = None,
+    model_kwargs: dict[str, Any] | None = None,
 ) -> PIL.Image.Image:
     """
     Transforms input images based on text prompts using a pretrained image-to-image model.
@@ -1217,8 +1215,8 @@ def automatic_speech_recognition(
     audio: pxt.Audio,
     *,
     model_id: str,
-    language: Optional[str] = None,
-    chunk_length_s: Optional[int] = None,
+    language: str | None = None,
+    chunk_length_s: int | None = None,
     return_timestamps: bool = False,
 ) -> str:
     """
@@ -1370,8 +1368,8 @@ def image_to_video(
     model_id: str,
     num_frames: int = 25,
     fps: int = 6,
-    seed: Optional[int] = None,
-    model_kwargs: Optional[dict[str, Any]] = None,
+    seed: int | None = None,
+    model_kwargs: dict[str, Any] | None = None,
 ) -> pxt.Video:
     """
     Generates videos from input images using a pretrained image-to-video model.
@@ -1487,7 +1485,7 @@ def image_to_video(
 
 
 def _lookup_model(
-    model_id: str, create: Callable[..., T], device: Optional[str] = None, pass_device_to_create: bool = False
+    model_id: str, create: Callable[..., T], device: str | None = None, pass_device_to_create: bool = False
 ) -> T:
     from torch import nn
 
@@ -1512,7 +1510,7 @@ def _lookup_processor(model_id: str, create: Callable[[str], T]) -> T:
     return _processor_cache[key]
 
 
-_model_cache: dict[tuple[str, Callable, Optional[str]], Any] = {}
+_model_cache: dict[tuple[str, Callable, str | None], Any] = {}
 _processor_cache: dict[tuple[str, Callable], Any] = {}
 
 

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.