pixeltable 0.2.20__py3-none-any.whl → 0.2.22__py3-none-any.whl

pixeltable/functions/globals.py

@@ -1,4 +1,8 @@
-from typing import Optional, Union, Any
+import builtins
+from typing import _GenericAlias  # type: ignore[attr-defined]
+from typing import Optional, Union
+
+import sqlalchemy as sql
 
 import pixeltable.func as func
 import pixeltable.type_system as ts
@@ -7,36 +11,44 @@ from pixeltable.utils.code import local_public_names
 
 
 # TODO: remove and replace calls with astype()
-def cast(expr: exprs.Expr, target_type: ts.ColumnType) -> exprs.Expr:
-    expr.col_type = target_type
+def cast(expr: exprs.Expr, target_type: Union[ts.ColumnType, type, _GenericAlias]) -> exprs.Expr:
+    expr.col_type = ts.ColumnType.normalize_type(target_type)
     return expr
 
 
-@func.uda(update_types=[ts.IntType()], value_type=ts.IntType(), allows_window=True, requires_order_by=False)
+@func.uda(
+    update_types=[ts.IntType(nullable=True)], value_type=ts.IntType(nullable=False),
+    allows_window=True, requires_order_by=False)
 class sum(func.Aggregator):
     """Sums the selected integers or floats."""
     def __init__(self):
-        self.sum: Union[int, float] = 0
-
-    def update(self, val: Union[int, float]) -> None:
-        if val is not None:
+        self.sum: Optional[int] = None
+
+    def update(self, val: Optional[int]) -> None:
+        if val is None:
+            return
+        if self.sum is None:
+            self.sum = val
+        else:
             self.sum += val
 
     def value(self) -> Union[int, float]:
         return self.sum
 
-# @sum.to_sql
-# def _(val: 'sqlalchemy.ColumnElements') -> Optional['sqlalchemy.ColumnElements']:
-#     import sqlalchemy as sql
-#     return sql.sql.functions.sum(val)
 
+@sum.to_sql
+def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+    # This can produce a Decimal. We are deliberately avoiding an explicit cast to a Bigint here, because that can
+    # cause overflows in Postgres. We're instead doing the conversion to the target type in SqlNode.__iter__().
+    return sql.sql.func.sum(val)
 
-@func.uda(update_types=[ts.IntType()], value_type=ts.IntType(), allows_window=True, requires_order_by=False)
+
+@func.uda(update_types=[ts.IntType(nullable=True)], value_type=ts.IntType(), allows_window=True, requires_order_by=False)
 class count(func.Aggregator):
     def __init__(self):
         self.count = 0
 
-    def update(self, val: int) -> None:
+    def update(self, val: Optional[int]) -> None:
         if val is not None:
             self.count += 1
 
@@ -44,57 +56,87 @@ class count(func.Aggregator):
         return self.count
 
 
-@func.uda(update_types=[ts.FloatType()], value_type=ts.FloatType(nullable=True), allows_window=True, requires_order_by=False)
-class max(func.Aggregator):
+@count.to_sql
+def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+    return sql.sql.func.count(val)
+
+
+@func.uda(
+    update_types=[ts.IntType(nullable=True)], value_type=ts.IntType(nullable=True), allows_window=True,
+    requires_order_by=False)
+class min(func.Aggregator):
     def __init__(self):
-        self.val = None
+        self.val: Optional[int] = None
 
-    def update(self, val: Optional[float]) -> None:
-        if val is not None:
-            if self.val is None:
-                self.val = val
-            else:
-                import builtins
-                self.val = builtins.max(self.val, val)
+    def update(self, val: Optional[int]) -> None:
+        if val is None:
+            return
+        if self.val is None:
+            self.val = val
+        else:
+            self.val = builtins.min(self.val, val)
 
-    def value(self) -> Optional[float]:
+    def value(self) -> Optional[int]:
         return self.val
 
 
-@func.uda(update_types=[ts.FloatType()], value_type=ts.FloatType(nullable=True), allows_window=True, requires_order_by=False)
-class min(func.Aggregator):
+@min.to_sql
+def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+    return sql.sql.func.min(val)
+
+
+@func.uda(
+    update_types=[ts.IntType(nullable=True)], value_type=ts.IntType(nullable=True), allows_window=True,
+    requires_order_by=False)
+class max(func.Aggregator):
     def __init__(self):
-        self.val = None
+        self.val: Optional[int] = None
 
-    def update(self, val: Optional[float]) -> None:
-        if val is not None:
-            if self.val is None:
-                self.val = val
-            else:
-                import builtins
-                self.val = builtins.min(self.val, val)
+    def update(self, val: Optional[int]) -> None:
+        if val is None:
+            return
+        if self.val is None:
+            self.val = val
+        else:
+            self.val = builtins.max(self.val, val)
 
-    def value(self) -> Optional[float]:
+    def value(self) -> Optional[int]:
         return self.val
 
 
-@func.uda(update_types=[ts.IntType()], value_type=ts.FloatType(), allows_window=False, requires_order_by=False)
+@max.to_sql
+def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+    return sql.sql.func.max(val)
+
+
+@func.uda(
+    update_types=[ts.IntType(nullable=True)], value_type=ts.FloatType(nullable=True), allows_window=False,
+    requires_order_by=False)
 class mean(func.Aggregator):
     def __init__(self):
-        self.sum = 0
+        self.sum: Optional[int] = None
         self.count = 0
 
-    def update(self, val: int) -> None:
-        if val is not None:
+    def update(self, val: Optional[int]) -> None:
+        if val is None:
+            return
+        if self.sum is None:
+            self.sum = val
+        else:
             self.sum += val
-            self.count += 1
+        self.count += 1
 
-    def value(self) -> float:
+    def value(self) -> Optional[float]:
         if self.count == 0:
             return None
         return self.sum / self.count
 
 
+@mean.to_sql
+def _(val: sql.ColumnElement) -> Optional[sql.ColumnElement]:
+    return sql.sql.func.avg(val)
+
+
 __all__ = local_public_names(__name__)
 
 

pixeltable/functions/huggingface.py

@@ -10,20 +10,18 @@ UDFs).
 from typing import Callable, TypeVar, Optional, Any
 
 import PIL.Image
-import numpy as np
 
 import pixeltable as pxt
 import pixeltable.env as env
-import pixeltable.type_system as ts
 from pixeltable.func import Batch
 from pixeltable.functions.util import resolve_torch_device, normalize_image_mode
 from pixeltable.utils.code import local_public_names
 
 
-@pxt.udf(batch_size=32, return_type=ts.ArrayType((None,), dtype=ts.FloatType()))
+@pxt.udf(batch_size=32)
 def sentence_transformer(
     sentence: Batch[str], *, model_id: str, normalize_embeddings: bool = False
-) -> Batch[np.ndarray]:
+) -> Batch[pxt.Array[(None,), float]]:
     """
     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)
@@ -59,14 +57,14 @@ def sentence_transformer(
 
 
 @sentence_transformer.conditional_return_type
-def _(model_id: str) -> ts.ArrayType:
+def _(model_id: str) -> pxt.ArrayType:
     try:
         from sentence_transformers import SentenceTransformer
 
         model = _lookup_model(model_id, SentenceTransformer)
-        return ts.ArrayType((model.get_sentence_embedding_dimension(),), dtype=ts.FloatType(), nullable=False)
+        return pxt.ArrayType((model.get_sentence_embedding_dimension(),), dtype=pxt.FloatType(), nullable=False)
     except ImportError:
-        return ts.ArrayType((None,), dtype=ts.FloatType(), nullable=False)
+        return pxt.ArrayType((None,), dtype=pxt.FloatType(), nullable=False)
 
 
 @pxt.udf
@@ -128,8 +126,8 @@ def cross_encoder_list(sentence1: str, sentences2: list, *, model_id: str) -> li
     return array.tolist()
 
 
-@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]:
+@pxt.udf(batch_size=32)
+def clip_text(text: Batch[str], *, model_id: str) -> Batch[pxt.Array[(None,), float]]:
     """
     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).
@@ -166,8 +164,8 @@ def clip_text(text: Batch[str], *, model_id: str) -> Batch[np.ndarray]:
     return [embeddings[i] for i in range(embeddings.shape[0])]
 
 
-@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]:
+@pxt.udf(batch_size=32)
+def clip_image(image: Batch[PIL.Image.Image], *, model_id: str) -> Batch[pxt.Array[(None,), float]]:
     """
     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).
@@ -206,14 +204,14 @@ def clip_image(image: Batch[PIL.Image.Image], *, model_id: str) -> Batch[np.ndar
 
 @clip_text.conditional_return_type
 @clip_image.conditional_return_type
-def _(model_id: str) -> ts.ArrayType:
+def _(model_id: str) -> pxt.ArrayType:
     try:
         from transformers import CLIPModel
 
         model = _lookup_model(model_id, CLIPModel.from_pretrained)
-        return ts.ArrayType((model.config.projection_dim,), dtype=ts.FloatType(), nullable=False)
+        return pxt.ArrayType((model.config.projection_dim,), dtype=pxt.FloatType(), nullable=False)
     except ImportError:
-        return ts.ArrayType((None,), dtype=ts.FloatType(), nullable=False)
+        return pxt.ArrayType((None,), dtype=pxt.FloatType(), nullable=False)
 
 
 @pxt.udf(batch_size=4)
@@ -288,7 +286,7 @@ def vit_for_image_classification(
     *,
     model_id: str,
     top_k: int = 5
-) -> Batch[list[dict[str, Any]]]:
+) -> Batch[dict[str, Any]]:
     """
     Computes image classifications for the specified image using a Vision Transformer (ViT) model.
     `model_id` should be a reference to a pretrained [ViT Model](https://huggingface.co/docs/transformers/en/model_doc/vit).
@@ -309,24 +307,24 @@ def vit_for_image_classification(
         top_k: The number of classes to return.
 
     Returns:
-        A list of the `top_k` highest-scoring classes for each image. Each element in the list is a dictionary
-            in the following format:
+        A dictionary containing the output of the image classification model, in the following format:
 
-            ```python
-            {
-                'p': 0.230,  # class probability
-                'class': 935,  # class ID
-                'label': 'mashed potato',  # class label
-            }
-            ```
+        ```python
+        {
+            'scores': [0.325, 0.198, 0.105],  # list of probabilities of the top-k most likely classes
+            'labels': [340, 353, 386],  # list of class IDs for the top-k most likely classes
+            'label_text': ['zebra', 'gazelle', 'African elephant, Loxodonta africana'],
+                # corresponding text names of the top-k most likely classes
+        ```
 
     Examples:
         Add a computed column that applies the model `google/vit-base-patch16-224` to an existing
-        Pixeltable column `image` of the table `tbl`:
+        Pixeltable column `image` of the table `tbl`, returning the 10 most likely classes for each image:
 
         >>> tbl['image_class'] = vit_for_image_classification(
         ...     tbl.image,
-        ...     model_id='google/vit-base-patch16-224'
+        ...     model_id='google/vit-base-patch16-224',
+        ...     top_k=10
         ... )
     """
     env.Env.get().require_package('transformers')
@@ -346,15 +344,14 @@ def vit_for_image_classification(
     probs = torch.softmax(logits, dim=-1)
     top_k_probs, top_k_indices = torch.topk(probs, top_k, dim=-1)
 
+    # There is no official post_process method for ViT models; for consistency, we structure the output
+    # the same way as the output of the DETR model given by `post_process_object_detection`.
     return [
-        [
-            {
-                'p': top_k_probs[n, k].item(),
-                'class': top_k_indices[n, k].item(),
-                'label': model.config.id2label[top_k_indices[n, k].item()],
-            }
-            for k in range(top_k_probs.shape[1])
-        ]
+        {
+            'scores': [top_k_probs[n, k].item() for k in range(top_k_probs.shape[1])],
+            'labels': [top_k_indices[n, k].item() for k in range(top_k_probs.shape[1])],
+            'label_text': [model.config.id2label[top_k_indices[n, k].item()] for k in range(top_k_probs.shape[1])],
+        }
         for n in range(top_k_probs.shape[0])
     ]
 

pixeltable/functions/image.py

@@ -15,13 +15,12 @@ from typing import Optional
 
 import PIL.Image
 
-import pixeltable.func as func
-import pixeltable.type_system as ts
-from pixeltable.utils.code import local_public_names
+import pixeltable as pxt
 from pixeltable.exprs import Expr
+from pixeltable.utils.code import local_public_names
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def b64_encode(img: PIL.Image.Image, image_format: str = 'png') -> str:
     """
     Convert image to a base64-encoded string.
@@ -38,7 +37,7 @@ 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, is_method=True)
+@pxt.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`.
@@ -48,7 +47,7 @@ def alpha_composite(im1: PIL.Image.Image, im2: PIL.Image.Image) -> PIL.Image.Ima
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.blend, is_method=True)
+@pxt.udf(substitute_fn=PIL.Image.blend, 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.
@@ -57,7 +56,7 @@ def blend(im1: PIL.Image.Image, im2: PIL.Image.Image, alpha: float) -> PIL.Image
     """
     pass
 
-@func.udf(substitute_fn=PIL.Image.composite, is_method=True)
+@pxt.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.
@@ -70,7 +69,7 @@ def composite(image1: PIL.Image.Image, image2: PIL.Image.Image, mask: PIL.Image.
 # PIL.Image.Image methods
 
 # Image.convert()
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def convert(self: PIL.Image.Image, mode: str) -> PIL.Image.Image:
     """
     Convert the image to a different mode.
@@ -85,14 +84,14 @@ def convert(self: PIL.Image.Image, mode: str) -> PIL.Image.Image:
 
 
 @convert.conditional_return_type
-def _(self: Expr, mode: str) -> ts.ColumnType:
+def _(self: Expr, mode: str) -> pxt.ColumnType:
     input_type = self.col_type
-    assert isinstance(input_type, ts.ImageType)
-    return ts.ImageType(size=input_type.size, mode=mode, nullable=input_type.nullable)
+    assert isinstance(input_type, pxt.ImageType)
+    return pxt.ImageType(size=input_type.size, mode=mode, nullable=input_type.nullable)
 
 
 # Image.crop()
-@func.udf(substitute_fn=PIL.Image.Image.crop, is_method=True)
+@pxt.udf(substitute_fn=PIL.Image.Image.crop, 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,16 +104,16 @@ def crop(self: PIL.Image.Image, box: tuple[int, int, int, int]) -> PIL.Image.Ima
 
 
 @crop.conditional_return_type
-def _(self: Expr, box: tuple[int, int, int, int]) -> ts.ColumnType:
+def _(self: Expr, box: tuple[int, int, int, int]) -> pxt.ColumnType:
     input_type = self.col_type
-    assert isinstance(input_type, ts.ImageType)
+    assert isinstance(input_type, pxt.ImageType)
     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
+        return pxt.ImageType(size=(box[2] - box[0], box[3] - box[1]), mode=input_type.mode, nullable=input_type.nullable)
+    return pxt.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, is_method=True)
+@pxt.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.
@@ -128,7 +127,7 @@ def getchannel(self: PIL.Image.Image, channel: int) -> PIL.Image.Image:
     pass
 
 
-@func.udf(is_method=True)
+@pxt.udf(is_method=True)
 def get_metadata(self: PIL.Image.Image) -> dict:
     """
     Return metadata for the image.
@@ -144,14 +143,29 @@ def get_metadata(self: PIL.Image.Image) -> dict:
 
 
 @getchannel.conditional_return_type
-def _(self: Expr) -> ts.ColumnType:
+def _(self: Expr) -> pxt.ColumnType:
     input_type = self.col_type
-    assert isinstance(input_type, ts.ImageType)
-    return ts.ImageType(size=input_type.size, mode='L', nullable=input_type.nullable)
+    assert isinstance(input_type, pxt.ImageType)
+    return pxt.ImageType(size=input_type.size, mode='L', nullable=input_type.nullable)
+
+
+# Image.point()
+@pxt.udf(is_method=True)
+def point(self: PIL.Image.Image, lut: list[int], mode: Optional[str] = None) -> PIL.Image.Image:
+    """
+    Map image pixels through a lookup table.
+
+    Equivalent to
+    [`PIL.Image.Image.point()`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.point)
+
+    Args:
+        lut: A lookup table.
+    """
+    return self.point(lut, mode=mode)
 
 
 # Image.resize()
-@func.udf(is_method=True)
+@pxt.udf(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.
@@ -163,14 +177,14 @@ def resize(self: PIL.Image.Image, size: tuple[int, int]) -> PIL.Image.Image:
 
 
 @resize.conditional_return_type
-def _(self: Expr, size: tuple[int, int]) -> ts.ColumnType:
+def _(self: Expr, size: tuple[int, int]) -> pxt.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)
+    assert isinstance(input_type, pxt.ImageType)
+    return pxt.ImageType(size=size, mode=input_type.mode, nullable=input_type.nullable)
 
 
 # Image.rotate()
-@func.udf(is_method=True)
+@pxt.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.
@@ -184,7 +198,7 @@ def rotate(self: PIL.Image.Image, angle: int) -> PIL.Image.Image:
     return self.rotate(angle)
 
 
-@func.udf(substitute_fn=PIL.Image.Image.effect_spread, is_method=True)
+@pxt.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.
@@ -198,7 +212,7 @@ def effect_spread(self: PIL.Image.Image, distance: int) -> PIL.Image.Image:
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.transpose, is_method=True)
+@pxt.udf(substitute_fn=PIL.Image.Image.transpose, is_method=True)
 def transpose(self: PIL.Image.Image, method: int) -> PIL.Image.Image:
     """
     Transpose the image.
@@ -215,11 +229,11 @@ def transpose(self: PIL.Image.Image, method: int) -> PIL.Image.Image:
 @rotate.conditional_return_type
 @effect_spread.conditional_return_type
 @transpose.conditional_return_type
-def _(self: Expr) -> ts.ColumnType:
+def _(self: Expr) -> pxt.ColumnType:
     return self.col_type
 
 
-@func.udf(substitute_fn=PIL.Image.Image.entropy, is_method=True)
+@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:
     """
     Returns the entropy of the image, optionally using a mask and extrema.
@@ -234,7 +248,7 @@ def entropy(self: PIL.Image.Image, mask: Optional[PIL.Image.Image] = None, extre
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getbands, is_method=True)
+@pxt.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.
@@ -245,7 +259,7 @@ def getbands(self: PIL.Image.Image) -> tuple[str]:
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getbbox, is_method=True)
+@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]:
     """
     Return a bounding box for the non-zero regions of the image.
@@ -258,7 +272,7 @@ def getbbox(self: PIL.Image.Image, *, alpha_only: bool = True) -> tuple[int, int
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getcolors, is_method=True)
+@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]:
     """
     Return a list of colors used in the image, up to a maximum of `maxcolors`.
@@ -272,7 +286,7 @@ def getcolors(self: PIL.Image.Image, maxcolors: int = 256) -> tuple[tuple[int, i
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getextrema, is_method=True)
+@pxt.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.
@@ -283,7 +297,7 @@ def getextrema(self: PIL.Image.Image) -> tuple[int, int]:
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getpalette, is_method=True)
+@pxt.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.
@@ -297,8 +311,8 @@ def getpalette(self: PIL.Image.Image, mode: Optional[str] = None) -> tuple[int]:
     pass
 
 
-@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]:
+@pxt.udf(is_method=True)
+def getpixel(self: PIL.Image.Image, xy: list) -> tuple[int]:
     """
     Return the pixel value at the given position. The position `xy` is a tuple containing the x and y coordinates.
 
@@ -309,10 +323,10 @@ def getpixel(self: PIL.Image.Image, xy: tuple[int, int]) -> tuple[int]:
         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))  # type: ignore[arg-type]
+    return self.getpixel(tuple(xy))
 
 
-@func.udf(substitute_fn=PIL.Image.Image.getprojection, is_method=True)
+@pxt.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.
@@ -323,7 +337,7 @@ def getprojection(self: PIL.Image.Image) -> tuple[int]:
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.histogram, is_method=True)
+@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]:
@@ -340,7 +354,7 @@ def histogram(
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.quantize, is_method=True)
+@pxt.udf(substitute_fn=PIL.Image.Image.quantize, is_method=True)
 def quantize(
     self: PIL.Image.Image,
     colors: int = 256,
@@ -365,7 +379,7 @@ def quantize(
     pass
 
 
-@func.udf(substitute_fn=PIL.Image.Image.reduce, is_method=True)
+@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:
     """
     Reduce the image by the given factor.
@@ -380,17 +394,17 @@ def reduce(self: PIL.Image.Image, factor: int, box: Optional[tuple[int, int, int
     pass
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def width(self: PIL.Image.Image) -> int:
     return self.width
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def height(self: PIL.Image.Image) -> int:
     return self.height
 
 
-@func.udf(is_property=True)
+@pxt.udf(is_property=True)
 def mode(self: PIL.Image.Image) -> str:
     return self.mode
 

pixeltable/functions/json.py

@@ -13,7 +13,6 @@ t.select(pxt.functions.json.make_list()).collect()
 from typing import Any
 
 import pixeltable as pxt
-import pixeltable.type_system as ts
 from pixeltable.utils.code import local_public_names