pixeltable 0.2.14__tar.gz → 0.2.15__tar.gz

{pixeltable-0.2.14 → pixeltable-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.2.14
+Version: 0.2.15
 Summary: Pixeltable: The Multimodal AI Data Plane
 Author: Pixeltable, Inc.
 Author-email: contact@pixeltable.com
@@ -21,9 +21,9 @@ Requires-Dist: more-itertools (>=10.2,<11.0)
 Requires-Dist: numpy (>=1.25)
 Requires-Dist: opencv-python-headless (>=4.7.0.68,<5.0.0.0)
 Requires-Dist: pandas (>=2.0,<3.0)
-Requires-Dist: pgserver (==0.1.4)
 Requires-Dist: pgvector (>=0.2.1,<0.3.0)
 Requires-Dist: pillow (>=9.3.0)
+Requires-Dist: pixeltable-pgserver (==0.2.4)
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.5,<3.0.0)
 Requires-Dist: pymupdf (>=1.24.1,<2.0.0)

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.2.14"
-__version_tuple__ = (0, 2, 14)
+__version__ = "0.2.15"
+__version_tuple__ = (0, 2, 15)

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/catalog/column.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional, Union, Callable, Any
-from uuid import UUID
+from typing import Any, Callable, Optional, Union
 
 import sqlalchemy as sql
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+
 from .globals import is_valid_identifier
 
 _logger = logging.getLogger('pixeltable')
@@ -21,7 +21,7 @@ class Column:
     def __init__(
             self, name: Optional[str], col_type: Optional[ts.ColumnType] = None,
             computed_with: Optional[Union['Expr', Callable]] = None,
-            is_pk: bool = False, stored: Optional[bool] = None,
+            is_pk: bool = False, stored: bool = True,
             col_id: Optional[int] = None, schema_version_add: Optional[int] = None,
             schema_version_drop: Optional[int] = None, sa_col_type: Optional[sql.sqltypes.TypeEngine] = None,
             records_errors: Optional[bool] = None, value_expr_dict: Optional[dict[str, Any]] = None,

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/catalog/table.py

@@ -434,8 +434,8 @@ class Table(SchemaObject):
         for name, spec in schema.items():
             col_type: Optional[ts.ColumnType] = None
             value_expr: Optional[exprs.Expr] = None
-            stored: Optional[bool] = None
             primary_key: Optional[bool] = None
+            stored = True
 
             if isinstance(spec, ts.ColumnType):
                 # TODO: create copy
@@ -455,7 +455,7 @@ class Table(SchemaObject):
                 if value_expr is not None and isinstance(value_expr, exprs.Expr):
                     # create copy so we can modify it
                     value_expr = value_expr.copy()
-                stored = spec.get('stored')
+                stored = spec.get('stored', True)
                 primary_key = spec.get('primary_key')
 
             column = Column(
@@ -478,12 +478,10 @@ class Table(SchemaObject):
             raise excs.Error(f'Column name conflicts with a registered query: {col.name!r}')
         if col.stored is False and not (col.is_computed and col.col_type.is_image_type()):
             raise excs.Error(f'Column {col.name!r}: stored={col.stored} only applies to computed image columns')
-        if col.stored is False and not (col.col_type.is_image_type() and not col.has_window_fn_call()):
+        if col.stored is False and col.has_window_fn_call():
             raise excs.Error((
                 f'Column {col.name!r}: stored={col.stored} is not valid for image columns computed with a streaming '
                 f'function'))
-        if col.stored is None:
-            col.stored = not (col.is_computed and col.col_type.is_image_type() and not col.has_window_fn_call())
 
     @classmethod
     def _verify_schema(cls, schema: list[Column]) -> None:

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/env.py

@@ -16,7 +16,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Callable, Optional, Dict, Any, List, TYPE_CHECKING
 
-import pgserver
+import pixeltable_pgserver
 import sqlalchemy as sql
 import yaml
 from tqdm import TqdmWarning
@@ -60,7 +60,7 @@ class Env:
         self._sa_engine: Optional[sql.engine.base.Engine] = None
         self._pgdata_dir: Optional[Path] = None
         self._db_name: Optional[str] = None
-        self._db_server: Optional[pgserver.PostgresServer] = None
+        self._db_server: Optional[pixeltable_pgserver.PostgresServer] = None
         self._db_url: Optional[str] = None
 
         # info about installed packages that are utilized by some parts of the code;
@@ -266,8 +266,8 @@ class Env:
         self._db_name = os.environ.get('PIXELTABLE_DB', 'pixeltable')
         self._pgdata_dir = Path(os.environ.get('PIXELTABLE_PGDATA', str(self._home / 'pgdata')))
 
-        # in pgserver.get_server(): cleanup_mode=None will leave db on for debugging purposes
-        self._db_server = pgserver.get_server(self._pgdata_dir, cleanup_mode=None)
+        # in pixeltable_pgserver.get_server(): cleanup_mode=None will leave db on for debugging purposes
+        self._db_server = pixeltable_pgserver.get_server(self._pgdata_dir, cleanup_mode=None)
         self._db_url = self._db_server.get_uri(database=self._db_name)
 
         if reinit_db:

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/exprs/arithmetic_expr.py

@@ -1,28 +1,28 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple
+
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
-from .globals import ArithmeticOperator
-from .expr import Expr
-from .data_row import DataRow
-from .row_builder import RowBuilder
 import pixeltable.exceptions as excs
-import pixeltable.catalog as catalog
 import pixeltable.type_system as ts
 
+from .data_row import DataRow
+from .expr import Expr
+from .globals import ArithmeticOperator
+from .row_builder import RowBuilder
+
 
 class ArithmeticExpr(Expr):
     """
     Allows arithmetic exprs on json paths
     """
     def __init__(self, operator: ArithmeticOperator, op1: Expr, op2: Expr):
-        # TODO: determine most specific common supertype
-        if op1.col_type.is_json_type() or op2.col_type.is_json_type():
+        if op1.col_type.is_json_type() or op2.col_type.is_json_type() or operator == ArithmeticOperator.DIV:
             # we assume it's a float
-            super().__init__(ts.FloatType())
+            super().__init__(ts.FloatType(nullable=(op1.col_type.nullable or op2.col_type.nullable)))
         else:
-            super().__init__(ts.ColumnType.supertype(op1.col_type, op2.col_type))
+            super().__init__(op1.col_type.supertype(op2.col_type))
         self.operator = operator
         self.components = [op1, op2]
 
@@ -43,7 +43,7 @@ class ArithmeticExpr(Expr):
     def _equals(self, other: ArithmeticExpr) -> bool:
         return self.operator == other.operator
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('operator', self.operator.value)]
 
     @property
@@ -55,6 +55,7 @@ class ArithmeticExpr(Expr):
         return self.components[1]
 
     def sql_expr(self) -> Optional[sql.ClauseElement]:
+        assert self.col_type.is_int_type() or self.col_type.is_float_type() or self.col_type.is_json_type()
         left = self._op1.sql_expr()
         right = self._op2.sql_expr()
         if left is None or right is None:
@@ -66,14 +67,31 @@ class ArithmeticExpr(Expr):
         if self.operator == ArithmeticOperator.MUL:
             return left * right
         if self.operator == ArithmeticOperator.DIV:
-            return left / right
+            assert self.col_type.is_float_type()
+            # We have to cast to a `float`, or else we'll get a `Decimal`
+            return sql.sql.expression.cast(left / right, sql.Float)
         if self.operator == ArithmeticOperator.MOD:
-            return left % right
+            if self.col_type.is_int_type():
+                return left % right
+            if self.col_type.is_float_type():
+                # Postgres does not support modulus for floats
+                return None
+        if self.operator == ArithmeticOperator.FLOORDIV:
+            # Postgres has a DIV operator, but it behaves differently from Python's // operator
+            # (Postgres rounds toward 0, Python rounds toward negative infinity)
+            # We need the behavior to be consistent, so that expressions will evaluate the same way
+            # whether or not their operands can be translated to SQL. These SQL clauses should
+            # mimic the behavior of Python's // operator.
+            if self.col_type.is_int_type():
+                return sql.sql.expression.cast(sql.func.floor(left / right), sql.Integer)
+            if self.col_type.is_float_type():
+                return sql.sql.expression.cast(sql.func.floor(left / right), sql.Float)
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         op1_val = data_row[self._op1.slot_idx]
         op2_val = data_row[self._op2.slot_idx]
-        # check types if we couldn't do that prior to execution
+
+        # if one or both columns is JsonTyped, we need a dynamic check that they are numeric
         if self._op1.col_type.is_json_type() and not isinstance(op1_val, int) and not isinstance(op1_val, float):
             raise excs.Error(
                 f'{self.operator} requires numeric type, but {self._op1} has type {type(op1_val).__name__}')
@@ -81,6 +99,11 @@ class ArithmeticExpr(Expr):
             raise excs.Error(
                 f'{self.operator} requires numeric type, but {self._op2} has type {type(op2_val).__name__}')
 
+        # if either operand is None, always return None
+        if op1_val is None or op2_val is None:
+            data_row[self.slot_idx] = None
+            return
+
         if self.operator == ArithmeticOperator.ADD:
             data_row[self.slot_idx] = op1_val + op2_val
         elif self.operator == ArithmeticOperator.SUB:
@@ -91,12 +114,14 @@ class ArithmeticExpr(Expr):
             data_row[self.slot_idx] = op1_val / op2_val
         elif self.operator == ArithmeticOperator.MOD:
             data_row[self.slot_idx] = op1_val % op2_val
+        elif self.operator == ArithmeticOperator.FLOORDIV:
+            data_row[self.slot_idx] = op1_val // op2_val
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         return {'operator': self.operator.value, **super()._as_dict()}
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> Expr:
         assert 'operator' in d
         assert len(components) == 2
         return cls(ArithmeticOperator(d['operator']), components[0], components[1])

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/exprs/expr.py

@@ -503,6 +503,9 @@ class Expr(abc.ABC):
             return Comparison(op, self, Literal(other))  # type: ignore[arg-type]
         raise TypeError(f'Other must be Expr or literal: {type(other)}')
 
+    def __neg__(self) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._make_arithmetic_expr(ArithmeticOperator.MUL, -1)
+
     def __add__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.ADD, other)
 
@@ -518,6 +521,27 @@ class Expr(abc.ABC):
     def __mod__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.MOD, other)
 
+    def __floordiv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._make_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
+
+    def __radd__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.ADD, other)
+
+    def __rsub__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.SUB, other)
+
+    def __rmul__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.MUL, other)
+
+    def __rtruediv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.DIV, other)
+
+    def __rmod__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.MOD, other)
+
+    def __rfloordiv__(self, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        return self._rmake_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
+
     def _make_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
         """
         other: Union[Expr, LiteralPythonTypes]
@@ -531,6 +555,19 @@ class Expr(abc.ABC):
             return ArithmeticExpr(op, self, Literal(other))  # type: ignore[arg-type]
         raise TypeError(f'Other must be Expr or literal: {type(other)}')
 
+    def _rmake_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'pixeltable.exprs.ArithmeticExpr':
+        """
+        Right-handed version of _make_arithmetic_expr. other must be a literal; if it were an Expr,
+        the operation would have already been evaluated in its left-handed form.
+        """
+        # TODO: check for compatibility
+        from .arithmetic_expr import ArithmeticExpr
+        from .literal import Literal
+        assert not isinstance(other, Expr)  # Else the left-handed form would have evaluated first
+        if isinstance(other, typing.get_args(LiteralPythonTypes)):
+            return ArithmeticExpr(op, Literal(other), self)  # type: ignore[arg-type]
+        raise TypeError(f'Other must be Expr or literal: {type(other)}')
+
     def __and__(self, other: object) -> Expr:
         if not isinstance(other, Expr):
             raise TypeError(f'Other needs to be an expression: {type(other)}')

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/exprs/function_call.py

@@ -200,7 +200,11 @@ class FunctionCall(Expr):
             if is_var_param:
                 pass
             else:
-                if not param.col_type.is_supertype_of(arg.col_type):
+                assert param.col_type is not None
+                # Check that the argument is consistent with the expected parameter type, with the allowance that
+                # non-nullable parameters can still accept nullable arguments (since function calls with Nones
+                # assigned to non-nullable parameters will always return None)
+                if not param.col_type.is_supertype_of(arg.col_type, ignore_nullable=True):
                     raise excs.Error(
                         f'Parameter {param_name}: argument type {arg.col_type} does not match parameter type '
                         f'{param.col_type}')

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/exprs/globals.py

@@ -68,6 +68,7 @@ class ArithmeticOperator(enum.Enum):
     MUL = 2
     DIV = 3
     MOD = 4
+    FLOORDIV = 5
 
     def __str__(self) -> str:
         if self == self.ADD:
@@ -80,4 +81,5 @@ class ArithmeticOperator(enum.Enum):
             return '/'
         if self == self.MOD:
             return '%'
-
+        if self == self.FLOORDIV:
+            return '//'

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/exprs/inline_array.py

@@ -51,9 +51,9 @@ class InlineArray(Expr):
             # try to infer the element type
             for idx, val in self.elements:
                 if idx is not None:
-                    inferred_element_type = ts.ColumnType.supertype(inferred_element_type, self.components[idx].col_type)
+                    inferred_element_type = inferred_element_type.supertype(self.components[idx].col_type)
                 else:
-                    inferred_element_type = ts.ColumnType.supertype(inferred_element_type, ts.ColumnType.infer_literal_type(val))
+                    inferred_element_type = inferred_element_type.supertype(ts.ColumnType.infer_literal_type(val))
                 if inferred_element_type is None:
                     break
 

{pixeltable-0.2.14 → pixeltable-0.2.15}/pixeltable/functions/__init__.py

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

pixeltable-0.2.15/pixeltable/functions/json.py

@@ -0,0 +1,46 @@
+"""
+Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for `JsonType`.
+
+Example:
+```python
+import pixeltable as pxt
+
+t = pxt.get_table(...)
+t.select(pxt.functions.json.make_list()).collect()
+```
+"""
+
+from typing import Any
+
+import pixeltable.func as func
+import pixeltable.type_system as ts
+from pixeltable.utils.code import local_public_names
+
+
+@func.uda(
+    update_types=[ts.JsonType(nullable=True)],
+    value_type=ts.JsonType(),
+    requires_order_by=False,
+    allows_window=False,
+)
+class make_list(func.Aggregator):
+    """
+    Collects arguments into a list.
+    """
+    def __init__(self):
+        self.output: list[Any] = []
+
+    def update(self, obj: Any) -> None:
+        if obj is None:
+            return
+        self.output.append(obj)
+
+    def value(self) -> list[Any]:
+        return self.output
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__():
+    return __all__

pixeltable-0.2.14/pixeltable/functions/eval.py → pixeltable-0.2.15/pixeltable/functions/vision.py

@@ -1,11 +1,29 @@
-from typing import List, Tuple, Dict
+"""
+Pixeltable [UDFs](https://pixeltable.readme.io/docs/user-defined-functions-udfs) for Computer Vision.
+
+Example:
+```python
+import pixeltable as pxt
+from pixeltable.functions import vision as pxtv
+
+t = pxt.get_table(...)
+t.select(pxtv.draw_bounding_boxes(t.img, boxes=t.boxes, label=t.labels)).collect()
+```
+"""
+
+import colorsys
+import hashlib
+import random
 from collections import defaultdict
-import sys
+from typing import Optional, Union, Any
 
+import PIL.Image
+import PIL.Image
 import numpy as np
 
-import pixeltable.type_system as ts
 import pixeltable.func as func
+import pixeltable.type_system as ts
+from pixeltable.utils.code import local_public_names
 
 
 # TODO: figure out a better submodule structure
@@ -14,7 +32,7 @@ import pixeltable.func as func
 # the following function has been adapted from MMEval
 # (sources at https://github.com/open-mmlab/mmeval)
 # Copyright (c) OpenMMLab. All rights reserved.
-def calculate_bboxes_area(bboxes: np.ndarray) -> np.ndarray:
+def __calculate_bboxes_area(bboxes: np.ndarray) -> np.ndarray:
     """Calculate area of bounding boxes.
 
     Args:
@@ -31,7 +49,7 @@ def calculate_bboxes_area(bboxes: np.ndarray) -> np.ndarray:
 # the following function has been adapted from MMEval
 # (sources at https://github.com/open-mmlab/mmeval)
 # Copyright (c) OpenMMLab. All rights reserved.
-def calculate_overlaps(bboxes1: np.ndarray, bboxes2: np.ndarray) -> np.ndarray:
+def __calculate_overlaps(bboxes1: np.ndarray, bboxes2: np.ndarray) -> np.ndarray:
     """Calculate the overlap between each bbox of bboxes1 and bboxes2.
 
     Args:
@@ -58,8 +76,8 @@ def calculate_overlaps(bboxes1: np.ndarray, bboxes2: np.ndarray) -> np.ndarray:
         exchange = False
 
     # Calculate the bboxes area.
-    area1 = calculate_bboxes_area(bboxes1)
-    area2 = calculate_bboxes_area(bboxes2)
+    area1 = __calculate_bboxes_area(bboxes1)
+    area2 = __calculate_bboxes_area(bboxes2)
     eps = np.finfo(np.float32).eps
 
     for i in range(bboxes1.shape[0]):
@@ -80,9 +98,9 @@ def calculate_overlaps(bboxes1: np.ndarray, bboxes2: np.ndarray) -> np.ndarray:
 # the following function has been adapted from MMEval
 # (sources at https://github.com/open-mmlab/mmeval)
 # Copyright (c) OpenMMLab. All rights reserved.
-def calculate_image_tpfp(
+def __calculate_image_tpfp(
     pred_bboxes: np.ndarray, pred_scores: np.ndarray, gt_bboxes: np.ndarray, min_iou: float
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray]:
     """Calculate the true positive and false positive on an image.
 
     Args:
@@ -95,11 +113,8 @@ def calculate_image_tpfp(
 
     Returns:
         tuple (tp, fp):
-
-        - tp (numpy.ndarray): Shape (N,),
-          the true positive flag of each predicted bbox on this image.
-        - fp (numpy.ndarray): Shape (N,),
-          the false positive flag of each predicted bbox on this image.
+        tp: Shape (N,), the true positive flag of each predicted bbox on this image.
+        fp: Shape (N,), the false positive flag of each predicted bbox on this image.
     """
     # Step 1. Concatenate `gt_bboxes` and `ignore_gt_bboxes`, then set
     # the `ignore_gt_flags`.
@@ -121,7 +136,7 @@ def calculate_image_tpfp(
 
     # Step 4. Calculate the IoUs between the predicted bboxes and the
     # ground truth bboxes.
-    ious = calculate_overlaps(pred_bboxes, gt_bboxes)
+    ious = __calculate_overlaps(pred_bboxes, gt_bboxes)
     # For each pred bbox, the max iou with all gts.
     ious_max = ious.max(axis=1)
     # For each pred bbox, which gt overlaps most with it.
@@ -160,14 +175,17 @@ def calculate_image_tpfp(
     ],
 )
 def eval_detections(
-    pred_bboxes: List[List[int]],
-    pred_labels: List[int],
-    pred_scores: List[float],
-    gt_bboxes: List[List[int]],
-    gt_labels: List[int],
-) -> Dict:
+    pred_bboxes: list[list[int]],
+    pred_labels: list[int],
+    pred_scores: list[float],
+    gt_bboxes: list[list[int]],
+    gt_labels: list[int],
+) -> dict:
+    """
+    Evaluates the performance of a set of predicted bounding boxes against a set of ground truth bounding boxes.
+    """
     class_idxs = list(set(pred_labels + gt_labels))
-    result: List[Dict] = []
+    result: list[dict] = []
     pred_bboxes_arr = np.asarray(pred_bboxes)
     pred_classes_arr = np.asarray(pred_labels)
     pred_scores_arr = np.asarray(pred_scores)
@@ -177,7 +195,7 @@ def eval_detections(
         pred_filter = pred_classes_arr == class_idx
         gt_filter = gt_classes_arr == class_idx
         class_pred_scores = pred_scores_arr[pred_filter]
-        tp, fp = calculate_image_tpfp(pred_bboxes_arr[pred_filter], class_pred_scores, gt_bboxes_arr[gt_filter], [0.5])
+        tp, fp = __calculate_image_tpfp(pred_bboxes_arr[pred_filter], class_pred_scores, gt_bboxes_arr[gt_filter], [0.5])
         ordered_class_pred_scores = -np.sort(-class_pred_scores)
         result.append(
             {
@@ -194,17 +212,21 @@ def eval_detections(
 
 @func.uda(update_types=[ts.JsonType()], value_type=ts.JsonType(), allows_std_agg=True, allows_window=False)
 class mean_ap(func.Aggregator):
+    """
+    Calculates the mean average precision (mAP) over
+    [`eval_detections()`][pixeltable.functions.vision.eval_detections] results.
+    """
     def __init__(self):
-        self.class_tpfp: Dict[int, List[Dict]] = defaultdict(list)
+        self.class_tpfp: dict[int, list[dict]] = defaultdict(list)
 
-    def update(self, eval_dicts: List[Dict]) -> None:
+    def update(self, eval_dicts: list[dict]) -> None:
         for eval_dict in eval_dicts:
             class_idx = eval_dict['class']
             self.class_tpfp[class_idx].append(eval_dict)
 
-    def value(self) -> Dict:
+    def value(self) -> dict:
         eps = np.finfo(np.float32).eps
-        result: Dict[int, float] = {}
+        result: dict[int, float] = {}
         for class_idx, tpfp in self.class_tpfp.items():
             a1 = [x['tp'] for x in tpfp]
             tp = np.concatenate([x['tp'] for x in tpfp], axis=0)
@@ -225,3 +247,124 @@ class mean_ap(func.Aggregator):
             ap = np.sum((mrec[ind + 1] - mrec[ind]) * mpre[ind + 1])
             result[class_idx] = ap.item()
         return result
+
+
+def _create_label_colors(labels: list[Any]) -> dict[Any, str]:
+    """
+    Create random colors for labels such that a particular label always gets the same color.
+
+    Returns:
+        dict mapping labels to colors
+    """
+    distinct_labels = set(labels)
+    result: dict[Any, str] = {}
+    for label in distinct_labels:
+        # consistent hash for the label
+        label_hash = int(hashlib.md5(str(label).encode()).hexdigest(), 16)
+        hue = (label_hash % 360) / 360.0
+        rgb = colorsys.hsv_to_rgb(hue, 0.7, 0.95)
+        hex_color = '#{:02x}{:02x}{:02x}'.format(int(rgb[0]*255), int(rgb[1]*255), int(rgb[2]*255))
+        result[label] = hex_color
+    return result
+
+
+@func.udf
+def draw_bounding_boxes(
+        img: PIL.Image.Image,
+        boxes: list[list[int]],
+        labels: Optional[list[Any]] = None,
+        color: Optional[str] = None,
+        label_colors: Optional[dict[Union[str, int], str]] = None,
+        box_colors: Optional[list[str]] = None,
+        fill: bool  = False,
+        width: int = 1,
+        font: Optional[str] = None,
+        font_size: Optional[int] = None,
+) -> PIL.Image.Image:
+    """
+    Draws bounding boxes on the given image.
+
+    Labels can be any type that supports `str()` and is hashable (e.g., strings, ints, etc.).
+
+    Colors can be specified as common HTML color names (e.g., 'red') supported by PIL's
+    [`ImageColor`](https://pillow.readthedocs.io/en/stable/reference/ImageColor.html#imagecolor-module) module or as
+    RGB hex codes (e.g., '#FF0000').
+
+    If no colors are specified, this function randomly assigns each label a specific color based on a hash of the label.
+
+    Args:
+        img: The image on which to draw the bounding boxes.
+        boxes: List of bounding boxes, each represented as [xmin, ymin, xmax, ymax].
+        labels: List of labels for each bounding box.
+        color: Single color to be used for all bounding boxes and labels.
+        label_colors: Dictionary mapping labels to colors.
+        box_colors: List of colors, one per bounding box.
+        fill: Whether to fill the bounding boxes with color.
+        width: Width of the bounding box borders.
+        font: Name of a system font or path to a TrueType font file, as required by
+            [`PIL.ImageFont.truetype()`](https://pillow.readthedocs.io/en/stable/reference/ImageFont.html#PIL.ImageFont.truetype).
+            If `None`, uses the default provided by
+            [`PIL.ImageFont.load_default()`](https://pillow.readthedocs.io/en/stable/reference/ImageFont.html#PIL.ImageFont.load_default).
+        font_size: Size of the font used for labels in points. Only used in conjunction with non-`None` `font` argument.
+
+    Returns:
+        The image with bounding boxes drawn on it.
+    """
+    color_params = sum([color is not None, label_colors is not None, box_colors is not None])
+    if color_params > 1:
+        raise ValueError("Only one of 'color', 'label_colors', or 'box_colors' can be set")
+
+    # ensure the number of labels matches the number of boxes
+    num_boxes = len(boxes)
+    if labels is None:
+        labels = [None] * num_boxes
+    elif len(labels) != num_boxes:
+        raise ValueError('Number of boxes and labels must match')
+
+    DEFAULT_COLOR = 'white'
+    if box_colors is not None:
+        if len(box_colors) != num_boxes:
+            raise ValueError('Number of boxes and box colors must match')
+    else:
+        if color is not None:
+            box_colors = [color] * num_boxes
+        elif label_colors is not None:
+            box_colors = [label_colors.get(label, DEFAULT_COLOR) for label in labels]
+        else:
+            label_colors = _create_label_colors(labels)
+            box_colors = [label_colors[label] for label in labels]
+
+    from PIL import ImageDraw, ImageFont, ImageColor
+    # set default font if not provided
+    if font is None:
+        txt_font = ImageFont.load_default()
+    else:
+        txt_font = ImageFont.truetype(font=font, size=font_size or 10)
+
+    img_to_draw = img.copy()
+    draw = ImageDraw.Draw(img_to_draw, 'RGBA' if fill else 'RGB')
+
+    for i, (bbox, label) in enumerate(zip(boxes, labels)):
+        # determine color for the current box and label
+        color = box_colors[i % len(box_colors)]
+
+        if fill:
+            rgb_color = ImageColor.getrgb(color)
+            fill_color = rgb_color + (100,)  # semi-transparent
+            draw.rectangle(bbox, outline=color, width=width, fill=fill_color)
+        else:
+            draw.rectangle(bbox, outline=color, width=width)
+
+        if label is not None:
+            label_str = str(label)
+            margin = width + 1
+            draw.text((bbox[0] + margin, bbox[1] + margin), label_str, fill=color, font=txt_font)
+
+    return img_to_draw
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__():
+    return __all__