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

pixeltable/functions/image.py

@@ -1,5 +1,5 @@
 """
-Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for `ImageType`.
+Pixeltable UDFs for `ImageType`.
 
 Example:
 ```python
@@ -10,8 +10,7 @@ t.select(t.img_col.convert('L')).collect()
 ```
 """
 
-import base64
-from typing import Optional
+from typing import Any, Literal
 
 import PIL.Image
 
@@ -19,6 +18,7 @@ import pixeltable as pxt
 import pixeltable.type_system as ts
 from pixeltable.exprs import Expr
 from pixeltable.utils.code import local_public_names
+from pixeltable.utils.image import to_base64
 
 
 @pxt.udf(is_method=True)
@@ -30,42 +30,37 @@ def b64_encode(img: PIL.Image.Image, image_format: str = 'png') -> str:
         img: image
         image_format: image format [supported by PIL](https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#fully-supported-formats)
     """
-    import io
+    return to_base64(img, format=image_format)
 
-    bytes_arr = io.BytesIO()
-    img.save(bytes_arr, format=image_format)
-    b64_bytes = base64.b64encode(bytes_arr.getvalue())
-    return b64_bytes.decode('utf-8')
 
-
-@pxt.udf(substitute_fn=PIL.Image.alpha_composite, is_method=True)
+@pxt.udf(is_method=True)
 def alpha_composite(im1: PIL.Image.Image, im2: PIL.Image.Image) -> PIL.Image.Image:
     """
     Alpha composite `im2` over `im1`.
 
     Equivalent to [`PIL.Image.alpha_composite()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.alpha_composite)
     """
-    pass
+    return PIL.Image.alpha_composite(im1, im2)
 
 
-@pxt.udf(substitute_fn=PIL.Image.blend, is_method=True)
+@pxt.udf(is_method=True)
 def blend(im1: PIL.Image.Image, im2: PIL.Image.Image, alpha: float) -> PIL.Image.Image:
     """
     Return a new image by interpolating between two input images, using a constant alpha.
 
     Equivalent to [`PIL.Image.blend()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.blend)
     """
-    pass
+    return PIL.Image.blend(im1, im2, alpha)
 
 
-@pxt.udf(substitute_fn=PIL.Image.composite, is_method=True)
+@pxt.udf(is_method=True)
 def composite(image1: PIL.Image.Image, image2: PIL.Image.Image, mask: PIL.Image.Image) -> PIL.Image.Image:
     """
     Return a composite image by blending two images using a mask.
 
     Equivalent to [`PIL.Image.composite()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.composite)
     """
-    pass
+    return PIL.Image.composite(image1, image2, mask)
 
 
 # PIL.Image.Image methods
@@ -96,7 +91,7 @@ def _(self: Expr, mode: str) -> ts.ColumnType:
 
 
 # Image.crop()
-@pxt.udf(substitute_fn=PIL.Image.Image.crop, is_method=True)
+@pxt.udf(is_method=True)
 def crop(self: PIL.Image.Image, box: tuple[int, int, int, int]) -> PIL.Image.Image:
     """
     Return a rectangular region from the image. The box is a 4-tuple defining the left, upper, right, and lower pixel
@@ -105,7 +100,7 @@ def crop(self: PIL.Image.Image, box: tuple[int, int, int, int]) -> PIL.Image.Ima
     Equivalent to
     [`PIL.Image.Image.crop()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.crop)
     """
-    pass
+    return self.crop(box)
 
 
 @crop.conditional_return_type
@@ -118,7 +113,7 @@ def _(self: Expr, box: tuple[int, int, int, int]) -> ts.ColumnType:
 
 
 # Image.getchannel()
-@pxt.udf(substitute_fn=PIL.Image.Image.getchannel, is_method=True)
+@pxt.udf(is_method=True)
 def getchannel(self: PIL.Image.Image, channel: int) -> PIL.Image.Image:
     """
     Return an L-mode image containing a single channel of the original image.
@@ -129,7 +124,7 @@ def getchannel(self: PIL.Image.Image, channel: int) -> PIL.Image.Image:
     Args:
         channel: The channel to extract. This is a 0-based index.
     """
-    pass
+    return self.getchannel(channel)
 
 
 @getchannel.conditional_return_type
@@ -156,7 +151,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.
 
@@ -203,7 +198,7 @@ def rotate(self: PIL.Image.Image, angle: int) -> PIL.Image.Image:
     return self.rotate(angle)
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.effect_spread, is_method=True)
+@pxt.udf(is_method=True)
 def effect_spread(self: PIL.Image.Image, distance: int) -> PIL.Image.Image:
     """
     Randomly spread pixels in an image.
@@ -214,11 +209,11 @@ def effect_spread(self: PIL.Image.Image, distance: int) -> PIL.Image.Image:
     Args:
         distance: The distance to spread pixels.
     """
-    pass
+    return self.effect_spread(distance)
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.transpose, is_method=True)
-def transpose(self: PIL.Image.Image, method: int) -> PIL.Image.Image:
+@pxt.udf(is_method=True)
+def transpose(self: PIL.Image.Image, method: Literal[0, 1, 2, 3, 4, 5, 6]) -> PIL.Image.Image:
     """
     Transpose the image.
 
@@ -230,7 +225,7 @@ def transpose(self: PIL.Image.Image, method: int) -> PIL.Image.Image:
             [Pillow documentation](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.transpose)
             for a list of supported methods.
     """
-    pass
+    return self.transpose(method)
 
 
 @rotate.conditional_return_type
@@ -240,8 +235,8 @@ def _(self: Expr) -> ts.ColumnType:
     return self.col_type
 
 
-@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:
+@pxt.udf(is_method=True)
+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.
 
@@ -252,22 +247,22 @@ def entropy(self: PIL.Image.Image, mask: Optional[PIL.Image.Image] = None, extre
         mask: An optional mask image.
         extrema: An optional list of extrema.
     """
-    pass
+    return self.entropy(mask, extrema)  # type: ignore[arg-type]
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.getbands, is_method=True)
-def getbands(self: PIL.Image.Image) -> tuple[str]:
+@pxt.udf(is_method=True)
+def getbands(self: PIL.Image.Image) -> tuple[str, ...]:
     """
     Return a tuple containing the names of the image bands.
 
     Equivalent to
     [`PIL.Image.Image.getbands()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getbands)
     """
-    pass
+    return self.getbands()
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.getbbox, is_method=True)
-def getbbox(self: PIL.Image.Image, *, alpha_only: bool = True) -> tuple[int, int, int, int]:
+@pxt.udf(is_method=True)
+def getbbox(self: PIL.Image.Image, *, alpha_only: bool = True) -> tuple[int, int, int, int] | None:
     """
     Return a bounding box for the non-zero regions of the image.
 
@@ -277,11 +272,11 @@ def getbbox(self: PIL.Image.Image, *, alpha_only: bool = True) -> tuple[int, int
         alpha_only: If `True`, and the image has an alpha channel, trim transparent pixels. Otherwise,
             trim pixels when all channels are zero.
     """
-    pass
+    return self.getbbox(alpha_only=alpha_only)
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.getcolors, is_method=True)
-def getcolors(self: PIL.Image.Image, maxcolors: int = 256) -> tuple[tuple[int, int, int], int]:
+@pxt.udf(is_method=True)
+def getcolors(self: PIL.Image.Image, maxcolors: int = 256) -> list[tuple[int, int]]:
     """
     Return a list of colors used in the image, up to a maximum of `maxcolors`.
 
@@ -291,10 +286,10 @@ def getcolors(self: PIL.Image.Image, maxcolors: int = 256) -> tuple[tuple[int, i
     Args:
         maxcolors: The maximum number of colors to return.
     """
-    pass
+    return self.getcolors(maxcolors)
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.getextrema, is_method=True)
+@pxt.udf(is_method=True)
 def getextrema(self: PIL.Image.Image) -> tuple[int, int]:
     """
     Return a 2-tuple containing the minimum and maximum pixel values of the image.
@@ -302,11 +297,11 @@ def getextrema(self: PIL.Image.Image) -> tuple[int, int]:
     Equivalent to
     [`PIL.Image.Image.getextrema()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getextrema)
     """
-    pass
+    return self.getextrema()
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.getpalette, is_method=True)
-def getpalette(self: PIL.Image.Image, mode: Optional[str] = None) -> tuple[int]:
+@pxt.udf(is_method=True)
+def getpalette(self: PIL.Image.Image, mode: str | None = None) -> list[int] | None:
     """
     Return the palette of the image, optionally converting it to a different mode.
 
@@ -316,7 +311,7 @@ def getpalette(self: PIL.Image.Image, mode: Optional[str] = None) -> tuple[int]:
     Args:
         mode: The mode to convert the palette to.
     """
-    pass
+    return self.getpalette(mode)
 
 
 @pxt.udf(is_method=True)
@@ -334,21 +329,19 @@ def getpixel(self: PIL.Image.Image, xy: list) -> tuple[int]:
     return self.getpixel(tuple(xy))
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.getprojection, is_method=True)
-def getprojection(self: PIL.Image.Image) -> tuple[int]:
+@pxt.udf(is_method=True)
+def getprojection(self: PIL.Image.Image) -> tuple[list[int], list[int]]:
     """
     Return two sequences representing the horizontal and vertical projection of the image.
 
     Equivalent to
     [`PIL.Image.Image.getprojection()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getprojection)
     """
-    pass
+    return self.getprojection()
 
 
-@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]:
+@pxt.udf(is_method=True)
+def histogram(self: PIL.Image.Image, mask: PIL.Image.Image | None = None, extrema: list | None = None) -> list[int]:
     """
     Return a histogram for the image.
 
@@ -359,16 +352,16 @@ def histogram(
         mask: An optional mask image.
         extrema: An optional list of extrema.
     """
-    pass
+    return self.histogram(mask, extrema)  # type: ignore[arg-type]
 
 
-@pxt.udf(substitute_fn=PIL.Image.Image.quantize, is_method=True)
+@pxt.udf(is_method=True)
 def quantize(
     self: PIL.Image.Image,
     colors: int = 256,
-    method: Optional[int] = None,
+    method: Literal[0, 1, 2, 3] | None = None,
     kmeans: int = 0,
-    palette: Optional[int] = None,
+    palette: PIL.Image.Image | None = None,
     dither: int = PIL.Image.Dither.FLOYDSTEINBERG,
 ) -> PIL.Image.Image:
     """
@@ -388,11 +381,11 @@ def quantize(
             [Pillow documentation](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.quantize)
             for a list of supported methods.
     """
-    pass
+    return self.quantize(colors, method, kmeans, palette, dither)
 
 
-@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:
+@pxt.udf(is_method=True)
+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.
 
@@ -404,24 +397,89 @@ def reduce(self: PIL.Image.Image, factor: int, box: Optional[tuple[int, int, int
         box: An optional 4-tuple of ints providing the source image region to be reduced. The values must be within
             (0, 0, width, height) rectangle. If omitted or None, the entire source is used.
     """
-    pass
+    return self.reduce(factor, box)
+
+
+@pxt.udf(is_method=True)
+def thumbnail(
+    self: PIL.Image.Image,
+    size: tuple[int, int],
+    resample: int = PIL.Image.Resampling.LANCZOS,
+    reducing_gap: float | None = 2.0,
+) -> PIL.Image.Image:
+    """
+    Create a thumbnail of the image.
+
+    Equivalent to
+    [`PIL.Image.Image.thumbnail()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.thumbnail)
+
+    Args:
+        size: The size of the thumbnail, as a tuple of (width, height).
+        resample: The resampling filter to use. See the
+            [Pillow documentation](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.thumbnail)
+            for a list of supported filters.
+        reducing_gap: The reducing gap to use.
+    """
+    result = self.copy()
+    result.thumbnail(size, PIL.Image.Resampling(resample), reducing_gap)
+    return result
 
 
 @pxt.udf(is_property=True)
 def width(self: PIL.Image.Image) -> int:
+    """
+    Return the width of the image.
+    """
     return self.width
 
 
 @pxt.udf(is_property=True)
 def height(self: PIL.Image.Image) -> int:
+    """
+    Return the height of the image.
+    """
     return self.height
 
 
 @pxt.udf(is_property=True)
 def mode(self: PIL.Image.Image) -> str:
+    """
+    Return the image mode.
+    """
     return self.mode
 
 
+def tile_iterator(
+    image: Any, tile_size: tuple[int, int], *, overlap: tuple[int, int] = (0, 0)
+) -> tuple[type[pxt.iterators.ComponentIterator], dict[str, Any]]:
+    """
+    Iterator over tiles of an image. Each image will be divided into tiles of size `tile_size`, and the tiles will be
+    iterated over in row-major order (left-to-right, then top-to-bottom). An optional `overlap` parameter may be
+    specified. If the tiles do not exactly cover the image, then the rightmost and bottommost tiles will be padded with
+    blackspace, so that the output images all have the exact size `tile_size`.
+
+    Args:
+        image: Image to split into tiles.
+        tile_size: Size of each tile, as a pair of integers `[width, height]`.
+        overlap: Amount of overlap between adjacent tiles, as a pair of integers `[width, height]`.
+
+    Examples:
+        This example assumes an existing table `tbl` with a column `img` of type `pxt.Image`.
+
+        Create a view that splits all images into 256x256 tiles with 32 pixels of overlap:
+
+        >>> pxt.create_view(
+        ...     'image_tiles',
+        ...     tbl,
+        ...     iterator=image_tile_iterator(tbl.img, tile_size=(256, 256), overlap=(32, 32))
+        ... )
+    """
+    kwargs: dict[str, Any] = {}
+    if overlap != (0, 0):
+        kwargs['overlap'] = overlap
+    return pxt.iterators.image.TileIterator._create(image=image, tile_size=tile_size, **kwargs)
+
+
 __all__ = local_public_names(__name__)
 
 

pixeltable/functions/json.py

@@ -1,5 +1,5 @@
 """
-Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for `JsonType`.
+Pixeltable UDFs for `JsonType`.
 
 Example:
 ```python

pixeltable/functions/llama_cpp.py

@@ -1,5 +1,12 @@
+"""
+Pixeltable UDFs for llama.cpp models.
+
+Provides integration with llama.cpp for running quantized language models locally,
+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
@@ -14,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,
-    args: 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.
@@ -35,14 +42,14 @@ def create_chat_completion(
         repo_id: The Hugging Face model repo id (if using a pretrained model).
         repo_filename: A filename or glob pattern to match the model file in the repo (optional, if using a
             pretrained model).
-        args: Additional arguments to pass to the `create_chat_completions` call, such as `max_tokens`, `temperature`,
-            `top_p`, and `top_k`. For details, see the
+        model_kwargs: Additional keyword args for the llama_cpp `create_chat_completions` API, such as `max_tokens`,
+            `temperature`, `top_p`, and `top_k`. For details, see the
             [llama_cpp create_chat_completions documentation](https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.create_chat_completion).
     """
     Env.get().require_package('llama_cpp', min_version=[0, 3, 1])
 
-    if args is None:
-        args = {}
+    if model_kwargs is None:
+        model_kwargs = {}
 
     if (model_path is None) == (repo_id is None):
         raise excs.Error('Exactly one of `model_path` or `repo_id` must be provided.')
@@ -56,7 +63,7 @@ def create_chat_completion(
     else:
         Env.get().require_package('huggingface_hub')
         llm = _lookup_pretrained_model(repo_id, repo_filename, n_gpu_layers)
-    return llm.create_chat_completion(messages, **args)  # type: ignore
+    return llm.create_chat_completion(messages, **model_kwargs)  # type: ignore
 
 
 def _is_gpu_available() -> bool:
@@ -81,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)
@@ -93,8 +100,16 @@ def _lookup_pretrained_model(repo_id: str, filename: Optional[str], n_gpu_layers
     return _model_cache[key]
 
 
-_model_cache: dict[tuple[str, str, int], Any] = {}
-_IS_GPU_AVAILABLE: Optional[bool] = None
+_model_cache: dict[tuple[str, str, int], 'llama_cpp.Llama'] = {}
+_IS_GPU_AVAILABLE: bool | None = None
+
+
+def cleanup() -> None:
+    for model in _model_cache.values():
+        if model._sampler is not None:
+            model._sampler.close()
+        model.close()
+    _model_cache.clear()
 
 
 __all__ = local_public_names(__name__)

pixeltable/functions/math.py

@@ -1,5 +1,5 @@
 """
-Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for mathematical operations.
+Pixeltable UDFs for mathematical operations.
 
 Example:
 ```python
@@ -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,11 +92,74 @@ 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:
-        return sql.func.round(sql.cast(self, sql.Numeric), sql.cast(digits, sql.Integer))
+        return sql.cast(sql.func.round(sql.cast(self, sql.Numeric), sql.cast(digits, sql.Integer)), sql.Float)
+
+
+@pxt.udf(is_method=True)
+def pow(self: int, other: int) -> float:
+    """
+    Raise `self` to the power of `other`.
+
+    Equivalent to Python [`self ** other`](https://docs.python.org/3/library/functions.html#pow).
+    """
+    return self**other
+
+
+@pow.to_sql
+def _(self: sql.ColumnElement, other: sql.ColumnElement) -> sql.ColumnElement:
+    return sql.func.pow(self, other)
+
+
+@pxt.udf(is_method=True)
+def bitwise_and(self: int, other: int) -> int:
+    """
+    Bitwise AND of two integers.
+
+    Equivalent to Python
+    [`self & other`](https://docs.python.org/3/library/stdtypes.html#bitwise-operations-on-integer-types).
+    """
+    return self & other
+
+
+@bitwise_and.to_sql
+def _(self: sql.ColumnElement, other: sql.ColumnElement) -> sql.ColumnElement:
+    return self.bitwise_and(other)
+
+
+@pxt.udf(is_method=True)
+def bitwise_or(self: int, other: int) -> int:
+    """
+    Bitwise OR of two integers.
+
+    Equivalent to Python
+    [`self | other`](https://docs.python.org/3/library/stdtypes.html#bitwise-operations-on-integer-types).
+    """
+    return self | other
+
+
+@bitwise_or.to_sql
+def _(self: sql.ColumnElement, other: sql.ColumnElement) -> sql.ColumnElement:
+    return self.bitwise_or(other)
+
+
+@pxt.udf(is_method=True)
+def bitwise_xor(self: int, other: int) -> int:
+    """
+    Bitwise XOR of two integers.
+
+    Equivalent to Python
+    [`self ^ other`](https://docs.python.org/3/library/stdtypes.html#bitwise-operations-on-integer-types).
+    """
+    return self ^ other
+
+
+@bitwise_xor.to_sql
+def _(self: sql.ColumnElement, other: sql.ColumnElement) -> sql.ColumnElement:
+    return self.bitwise_xor(other)
 
 
 __all__ = local_public_names(__name__)