pixeltable 0.2.13__py3-none-any.whl → 0.2.14__py3-none-any.whl

pixeltable/func/udf.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import List, Callable, Optional, overload, Any
 
-import pixeltable as pxt
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
 from .callable_function import CallableFunction
@@ -26,6 +25,8 @@ def udf(
         param_types: Optional[List[ts.ColumnType]] = None,
         batch_size: Optional[int] = None,
         substitute_fn: Optional[Callable] = None,
+        is_method: bool = False,
+        is_property: bool = False,
         _force_stored: bool = False
 ) -> Callable[[Callable], Function]: ...
 
@@ -56,6 +57,8 @@ def udf(*args, **kwargs):
         param_types = kwargs.pop('param_types', None)
         batch_size = kwargs.pop('batch_size', None)
         substitute_fn = kwargs.pop('substitute_fn', None)
+        is_method = kwargs.pop('is_method', None)
+        is_property = kwargs.pop('is_property', None)
         force_stored = kwargs.pop('_force_stored', False)
         if len(kwargs) > 0:
             raise excs.Error(f'Invalid @udf decorator kwargs: {", ".join(kwargs.keys())}')
@@ -64,8 +67,15 @@ def udf(*args, **kwargs):
 
         def decorator(decorated_fn: Callable):
             return make_function(
-                decorated_fn, return_type, param_types, batch_size,
-                substitute_fn=substitute_fn, force_stored=force_stored)
+                decorated_fn,
+                return_type,
+                param_types,
+                batch_size,
+                substitute_fn=substitute_fn,
+                is_method=is_method,
+                is_property=is_property,
+                force_stored=force_stored
+            )
 
         return decorator
 
@@ -76,6 +86,8 @@ def make_function(
     param_types: Optional[List[ts.ColumnType]] = None,
     batch_size: Optional[int] = None,
     substitute_fn: Optional[Callable] = None,
+    is_method: bool = False,
+    is_property: bool = False,
     function_name: Optional[str] = None,
     force_stored: bool = False
 ) -> Function:
@@ -112,6 +124,15 @@ def make_function(
     if batch_size is None and len(sig.batched_parameters) > 0:
         raise excs.Error(f'{errmsg_name}(): batched parameters in udf, but no `batch_size` given')
 
+    if is_method and is_property:
+        raise excs.Error(f'Cannot specify both `is_method` and `is_property` (in function `{function_name}`)')
+    if is_property and len(sig.parameters) != 1:
+        raise excs.Error(
+            f"`is_property=True` expects a UDF with exactly 1 parameter, but `{function_name}` has {len(sig.parameters)}"
+        )
+    if (is_method or is_property) and function_path is None:
+        raise excs.Error('Stored functions cannot be declared using `is_method` or `is_property`')
+
     if substitute_fn is None:
         py_fn = decorated_fn
     else:
@@ -120,7 +141,14 @@ def make_function(
         py_fn = substitute_fn
 
     result = CallableFunction(
-        signature=sig, py_fn=py_fn, self_path=function_path, self_name=function_name, batch_size=batch_size)
+        signature=sig,
+        py_fn=py_fn,
+        self_path=function_path,
+        self_name=function_name,
+        batch_size=batch_size,
+        is_method=is_method,
+        is_property=is_property
+    )
 
     # If this function is part of a module, register it
     if function_path is not None:

pixeltable/functions/__init__.py

@@ -1,4 +1,4 @@
-from . import fireworks, huggingface, image, openai, string, together, video
+from . import fireworks, huggingface, image, openai, string, together, video, timestamp
 from .globals import *
 from pixeltable.utils.code import local_public_names
 

pixeltable/functions/fireworks.py

@@ -1,3 +1,10 @@
+"""
+Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs)
+that wrap various endpoints from the Fireworks AI API. In order to use them, you must
+first `pip install fireworks-ai` and configure your Fireworks AI credentials, as described in
+the [Working with Fireworks](https://pixeltable.readme.io/docs/working-with-fireworks) tutorial.
+"""
+
 from typing import Optional, TYPE_CHECKING
 
 import pixeltable as pxt
@@ -29,6 +36,32 @@ def chat_completions(
     top_p: Optional[float] = None,
     temperature: Optional[float] = None,
 ) -> dict:
+    """
+    Creates a model response for the given chat conversation.
+
+    Equivalent to the Fireworks AI `chat/completions` API endpoint.
+    For additional details, see: [https://docs.fireworks.ai/api-reference/post-chatcompletions](https://docs.fireworks.ai/api-reference/post-chatcompletions)
+
+    __Requirements:__
+
+    - `pip install fireworks-ai`
+
+    Args:
+        messages: A list of messages comprising the conversation so far.
+        model: The name of the model to use.
+
+    For details on the other parameters, see: [https://docs.fireworks.ai/api-reference/post-chatcompletions](https://docs.fireworks.ai/api-reference/post-chatcompletions)
+
+    Returns:
+        A dictionary containing the response and other metadata.
+
+    Examples:
+        Add a computed column that applies the model `accounts/fireworks/models/mixtral-8x22b-instruct`
+        to an existing Pixeltable column `tbl.prompt` of the table `tbl`:
+
+        >>> messages = [{'role': 'user', 'content': tbl.prompt}]
+        ... tbl['response'] = chat_completions(tbl.prompt, model='accounts/fireworks/models/mixtral-8x22b-instruct')
+    """
     kwargs = {'max_tokens': max_tokens, 'top_k': top_k, 'top_p': top_p, 'temperature': temperature}
     kwargs_not_none = {k: v for k, v in kwargs.items() if v is not None}
     return _fireworks_client().chat.completions.create(model=model, messages=messages, **kwargs_not_none).dict()

pixeltable/functions/huggingface.py

@@ -25,7 +25,7 @@ def sentence_transformer(
     sentence: Batch[str], *, model_id: str, normalize_embeddings: bool = False
 ) -> Batch[np.ndarray]:
     """
-    Runs the specified pretrained sentence-transformers model. `model_id` should be a pretrained model, as described
+    Computes sentence embeddings. `model_id` should be a pretrained Sentence Transformers model, as described
     in the [Sentence Transformers Pretrained Models](https://sbert.net/docs/sentence_transformer/pretrained_models.html)
     documentation.
 
@@ -83,8 +83,8 @@ def sentence_transformer_list(sentences: list, *, model_id: str, normalize_embed
 @pxt.udf(batch_size=32)
 def cross_encoder(sentences1: Batch[str], sentences2: Batch[str], *, model_id: str) -> Batch[float]:
     """
-    Runs the specified cross-encoder model to compute similarity scores for pairs of sentences.
-    `model_id` should be a pretrained model, as described in the
+    Performs predicts on the given sentence pair.
+    `model_id` should be a pretrained Cross-Encoder model, as described in the
     [Cross-Encoder Pretrained Models](https://www.sbert.net/docs/cross_encoder/pretrained_models.html)
     documentation.
 
@@ -130,7 +130,27 @@ def cross_encoder_list(sentence1: str, sentences2: list, *, model_id: str) -> li
 
 @pxt.udf(batch_size=32, return_type=ts.ArrayType((None,), dtype=ts.FloatType(), nullable=False))
 def clip_text(text: Batch[str], *, model_id: str) -> Batch[np.ndarray]:
-    """Runs the specified CLIP model on text."""
+    """
+    Computes a CLIP embedding for the specified text. `model_id` should be a reference to a pretrained
+    [CLIP Model](https://huggingface.co/docs/transformers/model_doc/clip).
+
+    __Requirements:__
+
+    - `pip install transformers`
+
+    Args:
+        text: The string to embed.
+        model_id: The pretrained model to use for the embedding.
+
+    Returns:
+        An array containing the output of the embedding model.
+
+    Examples:
+        Add a computed column that applies the model `openai/clip-vit-base-patch32` to an existing
+        Pixeltable column `tbl.text` of the table `tbl`:
+
+        >>> tbl['result'] = clip_text(tbl.text, model_id='openai/clip-vit-base-patch32')
+    """
     env.Env.get().require_package('transformers')
     device = resolve_torch_device('auto')
     import torch
@@ -148,7 +168,27 @@ def clip_text(text: Batch[str], *, model_id: str) -> Batch[np.ndarray]:
 
 @pxt.udf(batch_size=32, return_type=ts.ArrayType((None,), dtype=ts.FloatType(), nullable=False))
 def clip_image(image: Batch[PIL.Image.Image], *, model_id: str) -> Batch[np.ndarray]:
-    """Runs the specified CLIP model on images."""
+    """
+    Computes a CLIP embedding for the specified image. `model_id` should be a reference to a pretrained
+    [CLIP Model](https://huggingface.co/docs/transformers/model_doc/clip).
+
+    __Requirements:__
+
+    - `pip install transformers`
+
+    Args:
+        image: The image to embed.
+        model_id: The pretrained model to use for the embedding.
+
+    Returns:
+        An array containing the output of the embedding model.
+
+    Examples:
+        Add a computed column that applies the model `openai/clip-vit-base-patch32` to an existing
+        Pixeltable column `tbl.image` of the table `tbl`:
+
+        >>> tbl['result'] = clip_image(tbl.image, model_id='openai/clip-vit-base-patch32')
+    """
     env.Env.get().require_package('transformers')
     device = resolve_torch_device('auto')
     import torch
@@ -178,7 +218,41 @@ def _(model_id: str) -> ts.ArrayType:
 
 @pxt.udf(batch_size=4)
 def detr_for_object_detection(image: Batch[PIL.Image.Image], *, model_id: str, threshold: float = 0.5) -> Batch[dict]:
-    """Runs the specified DETR model."""
+    """
+    Computes DETR object detections for the specified image. `model_id` should be a reference to a pretrained
+    [DETR Model](https://huggingface.co/docs/transformers/model_doc/detr).
+
+    __Requirements:__
+
+    - `pip install transformers`
+
+    Args:
+        image: The image to embed.
+        model_id: The pretrained model to use for the embedding.
+
+    Returns:
+        A dictionary containing the output of the object detection model, in the following format:
+
+    ```python
+    {
+        'scores': [0.99, 0.999],  # list of confidence scores for each detected object
+        'labels': [25, 25],  # list of COCO class labels for each detected object
+        'label_text': ['giraffe', 'giraffe'],  # corresponding text names of class labels
+        'boxes': [[51.942, 356.174, 181.481, 413.975], [383.225, 58.66, 605.64, 361.346]]
+            # list of bounding boxes for each detected object, as [x1, y1, x2, y2]
+    }
+    ```
+
+    Examples:
+        Add a computed column that applies the model `facebook/detr-resnet-50` to an existing
+        Pixeltable column `tbl.image` of the table `tbl`:
+
+        >>> tbl['detections'] = detr_for_object_detection(
+        ...     tbl.image,
+        ...     model_id='facebook/detr-resnet-50',
+        ...     threshold=0.8
+        ... )
+    """
     env.Env.get().require_package('transformers')
     device = resolve_torch_device('auto')
     import torch
@@ -210,6 +284,22 @@ def detr_for_object_detection(image: Batch[PIL.Image.Image], *, model_id: str, t
 
 @pxt.udf
 def detr_to_coco(image: PIL.Image.Image, detr_info: dict[str, Any]) -> dict[str, Any]:
+    """
+    Converts the output of a DETR object detection model to COCO format.
+
+    Args:
+        image: The image for which detections were computed.
+        detr_info: The output of a DETR object detection model, as returned by `detr_for_object_detection`.
+
+    Returns:
+        A dictionary containing the data from `detr_info`, converted to COCO format.
+
+    Examples:
+        Add a computed column that converts the output `tbl.detections` to COCO format, where `tbl.image`
+        is the image for which detections were computed:
+
+        >>> tbl['detections_coco'] = detr_to_coco(tbl.image, tbl.detections)
+    """
     bboxes, labels = detr_info['boxes'], detr_info['labels']
     annotations = [
         {'bbox': [bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]], 'category': label}

pixeltable/functions/image.py

@@ -11,7 +11,7 @@ t.select(t.img_col.convert('L')).collect()
 """
 
 import base64
-from typing import Optional, Tuple
+from typing import Optional
 
 import PIL.Image
 
@@ -21,9 +21,15 @@ from pixeltable.utils.code import local_public_names
 from pixeltable.exprs import Expr
 
 
-@func.udf
+@func.udf(is_method=True)
 def b64_encode(img: PIL.Image.Image, image_format: str = 'png') -> str:
-    # Encode this image as a b64-encoded png.
+    """
+    Convert image to a base64-encoded string.
+
+    Args:
+        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
 
     bytes_arr = io.BytesIO()
@@ -32,31 +38,48 @@ def b64_encode(img: PIL.Image.Image, image_format: str = 'png') -> str:
     return b64_bytes.decode('utf-8')
 
 
-@func.udf(substitute_fn=PIL.Image.alpha_composite)
+@func.udf(substitute_fn=PIL.Image.alpha_composite, 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
 
 
-@func.udf(substitute_fn=PIL.Image.blend)
+@func.udf(substitute_fn=PIL.Image.blend, is_method=True)
 def blend(im1: PIL.Image.Image, im2: PIL.Image.Image, alpha: float) -> PIL.Image.Image:
-    pass
+    """
+    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
 
-@func.udf(substitute_fn=PIL.Image.composite)
+@func.udf(substitute_fn=PIL.Image.composite, 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
 
 
 # PIL.Image.Image methods
 
-
 # Image.convert()
-@func.udf
+@func.udf(is_method=True)
 def convert(self: PIL.Image.Image, mode: str) -> PIL.Image.Image:
     """
     Convert the image to a different mode.
 
-    Equivalent to [`PIL.Image.Image.convert()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.convert).
+    Equivalent to
+    [`PIL.Image.Image.convert()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.convert).
+
+    Args:
+        mode: The mode to convert to. See the [Pillow documentation](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#concept-modes) for a list of supported modes.
     """
     return self.convert(mode)
 
@@ -69,23 +92,39 @@ def _(self: Expr, mode: str) -> ts.ColumnType:
 
 
 # Image.crop()
-@func.udf(substitute_fn=PIL.Image.Image.crop, param_types=[ts.ImageType(), ts.ArrayType((4,), dtype=ts.IntType())])
-def crop(self: PIL.Image.Image, box: Tuple[int, int, int, int]) -> PIL.Image.Image:
+@func.udf(substitute_fn=PIL.Image.Image.crop, param_types=[ts.ImageType(), ts.ArrayType((4,), dtype=ts.IntType())], 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
+    coordinates.
+
+    Equivalent to
+    [`PIL.Image.Image.crop()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.crop)
+    """
     pass
 
 
 @crop.conditional_return_type
-def _(self: Expr, box: Tuple[int, int, int, int]) -> ts.ColumnType:
+def _(self: Expr, box: tuple[int, int, int, int]) -> ts.ColumnType:
     input_type = self.col_type
     assert isinstance(input_type, ts.ImageType)
-    if isinstance(box, list) and all(isinstance(x, int) for x in box):
+    if (isinstance(box, list) or isinstance(box, tuple)) and len(box) == 4 and all(isinstance(x, int) for x in box):
         return ts.ImageType(size=(box[2] - box[0], box[3] - box[1]), mode=input_type.mode, nullable=input_type.nullable)
     return ts.ImageType(mode=input_type.mode, nullable=input_type.nullable)  # we can't compute the size statically
 
 
 # Image.getchannel()
-@func.udf(substitute_fn=PIL.Image.Image.getchannel)
+@func.udf(substitute_fn=PIL.Image.Image.getchannel, 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.
+
+    Equivalent to
+    [`PIL.Image.Image.getchannel()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getchannel)
+
+    Args:
+        channel: The channel to extract. This is a 0-based index.
+    """
     pass
 
 
@@ -97,31 +136,64 @@ def _(self: Expr) -> ts.ColumnType:
 
 
 # Image.resize()
-@func.udf(param_types=[ts.ImageType(), ts.ArrayType((2,), dtype=ts.IntType())])
-def resize(self: PIL.Image.Image, size: Tuple[int, int]) -> PIL.Image.Image:
+@func.udf(param_types=[ts.ImageType(), ts.ArrayType((2,), dtype=ts.IntType())], is_method=True)
+def resize(self: PIL.Image.Image, size: tuple[int, int]) -> PIL.Image.Image:
+    """
+    Return a resized copy of the image. The size parameter is a tuple containing the width and height of the new image.
+
+    Equivalent to
+    [`PIL.Image.Image.resize()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.resize)
+    """
     return self.resize(size)
 
 
 @resize.conditional_return_type
-def _(self: Expr, size: Tuple[int, int]) -> ts.ColumnType:
+def _(self: Expr, size: tuple[int, int]) -> ts.ColumnType:
     input_type = self.col_type
     assert isinstance(input_type, ts.ImageType)
     return ts.ImageType(size=size, mode=input_type.mode, nullable=input_type.nullable)
 
 
 # Image.rotate()
-@func.udf
+@func.udf(is_method=True)
 def rotate(self: PIL.Image.Image, angle: int) -> PIL.Image.Image:
+    """
+    Return a copy of the image rotated by the given angle.
+
+    Equivalent to
+    [`PIL.Image.Image.rotate()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.rotate)
+
+    Args:
+        angle: The angle to rotate the image, in degrees. Positive angles are counter-clockwise.
+    """
     return self.rotate(angle)
 
 
-@func.udf(substitute_fn=PIL.Image.Image.effect_spread)
+@func.udf(substitute_fn=PIL.Image.Image.effect_spread, is_method=True)
 def effect_spread(self: PIL.Image.Image, distance: int) -> PIL.Image.Image:
+    """
+    Randomly spread pixels in an image.
+
+    Equivalent to
+    [`PIL.Image.Image.effect_spread()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.effect_spread)
+
+    Args:
+        distance: The distance to spread pixels.
+    """
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.transpose)
+@func.udf(substitute_fn=PIL.Image.Image.transpose, is_method=True)
 def transpose(self: PIL.Image.Image, method: int) -> PIL.Image.Image:
+    """
+    Transpose the image.
+
+    Equivalent to
+    [`PIL.Image.Image.transpose()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.transpose)
+
+    Args:
+        method: The transpose method. See the [Pillow documentation](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.transpose) for a list of supported methods.
+    """
     pass
 
 
@@ -132,53 +204,128 @@ def _(self: Expr) -> ts.ColumnType:
     return self.col_type
 
 
-@func.udf(substitute_fn=PIL.Image.Image.entropy)
+@func.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:
+    """
+    Returns the entropy of the image, optionally using a mask and extrema.
+
+    Equivalent to
+    [`PIL.Image.Image.entropy()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.entropy)
+
+    Args:
+        mask: An optional mask image.
+        extrema: An optional list of extrema.
+    """
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getbands)
-def getbands(self: PIL.Image.Image) -> Tuple[str]:
+@func.udf(substitute_fn=PIL.Image.Image.getbands, 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
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getbbox)
-def getbbox(self: PIL.Image.Image) -> Tuple[int, int, int, int]:
+@func.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]:
+    """
+    Return a bounding box for the non-zero regions of the image.
+
+    Equivalent to [`PIL.Image.Image.getbbox()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getbbox)
+
+    Args:
+        alpha_only: If `True`, and the image has an alpha channel, trim transparent pixels. Otherwise, trim pixels when all channels are zero.
+    """
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getcolors)
-def getcolors(self: PIL.Image.Image, maxcolors: int) -> Tuple[Tuple[int, int, int], int]:
+@func.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]:
+    """
+    Return a list of colors used in the image, up to a maximum of `maxcolors`.
+
+    Equivalent to
+    [`PIL.Image.Image.getcolors()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getcolors)
+
+    Args:
+        maxcolors: The maximum number of colors to return.
+    """
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getextrema)
-def getextrema(self: PIL.Image.Image) -> Tuple[int, int]:
+@func.udf(substitute_fn=PIL.Image.Image.getextrema, 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.
+
+    Equivalent to
+    [`PIL.Image.Image.getextrema()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getextrema)
+    """
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getpalette)
-def getpalette(self: PIL.Image.Image, mode: Optional[str] = None) -> Tuple[int]:
+@func.udf(substitute_fn=PIL.Image.Image.getpalette, is_method=True)
+def getpalette(self: PIL.Image.Image, mode: Optional[str] = None) -> tuple[int]:
+    """
+    Return the palette of the image, optionally converting it to a different mode.
+
+    Equivalent to
+    [`PIL.Image.Image.getpalette()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getpalette)
+
+    Args:
+        mode: The mode to convert the palette to.
+    """
     pass
 
 
-@func.udf(param_types=[ts.ImageType(), ts.ArrayType((2,), dtype=ts.IntType())])
-def getpixel(self: PIL.Image.Image, xy: tuple[int, int]) -> Tuple[int]:
+@func.udf(param_types=[ts.ImageType(), ts.ArrayType((2,), dtype=ts.IntType())], is_method=True)
+def getpixel(self: PIL.Image.Image, xy: tuple[int, int]) -> tuple[int]:
+    """
+    Return the pixel value at the given position. The position `xy` is a tuple containing the x and y coordinates.
+
+    Equivalent to
+    [`PIL.Image.Image.getpixel()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.getpixel)
+
+    Args:
+        xy: The coordinates, given as (x, y).
+    """
     # `xy` will be a list; `tuple(xy)` is necessary for pillow 9 compatibility
     return self.getpixel(tuple(xy))
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getprojection)
-def getprojection(self: PIL.Image.Image) -> Tuple[int]:
+@func.udf(substitute_fn=PIL.Image.Image.getprojection, is_method=True)
+def getprojection(self: PIL.Image.Image) -> tuple[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
 
 
-@func.udf(substitute_fn=PIL.Image.Image.histogram)
-def histogram(self: PIL.Image.Image, mask: PIL.Image.Image, extrema: Optional[list] = None) -> Tuple[int]:
+@func.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]:
+    """
+    Return a histogram for the image.
+
+    Equivalent to
+    [`PIL.Image.Image.histogram()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.histogram)
+
+    Args:
+        mask: An optional mask image.
+        extrema: An optional list of extrema.
+    """
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.quantize)
+@func.udf(substitute_fn=PIL.Image.Image.quantize, is_method=True)
 def quantize(
     self: PIL.Image.Image,
     colors: int = 256,
@@ -187,14 +334,52 @@ def quantize(
     palette: Optional[int] = None,
     dither: int = PIL.Image.Dither.FLOYDSTEINBERG,
 ) -> PIL.Image.Image:
+    """
+     Convert the image to 'P' mode with the specified number of colors.
+
+     Equivalent to
+     [`PIL.Image.Image.quantize()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.quantize)
+
+    Args:
+        colors: The number of colors to quantize to.
+        method: The quantization method. See the [Pillow documentation](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.quantize) for a list of supported methods.
+        kmeans: The number of k-means clusters to use.
+        palette: The palette to use.
+        dither: The dithering method. See the [Pillow documentation](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.quantize) for a list of supported methods.
+     """
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.reduce)
-def reduce(self: PIL.Image.Image, factor: int, box: Optional[Tuple[int]] = None) -> PIL.Image.Image:
+@func.udf(substitute_fn=PIL.Image.Image.reduce, is_method=True)
+def reduce(self: PIL.Image.Image, factor: int, box: Optional[tuple[int]] = None) -> PIL.Image.Image:
+    """
+    Reduce the image by the given factor.
+
+    Equivalent to
+    [`PIL.Image.Image.reduce()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.reduce)
+
+    Args:
+        factor: The reduction factor.
+        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
 
 
+@func.udf(is_property=True)
+def width(self: PIL.Image.Image) -> int:
+    return self.width
+
+
+@func.udf(is_property=True)
+def height(self: PIL.Image.Image) -> int:
+    return self.height
+
+
+@func.udf(is_property=True)
+def mode(self: PIL.Image.Image) -> str:
+    return self.mode
+
+
 __all__ = local_public_names(__name__)