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

pixeltable/ext/functions/whisperx.py

@@ -1,8 +1,9 @@
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
 
-import torch
-import whisperx
-from whisperx.asr import FasterWhisperPipeline
+from pixeltable.utils.code import local_public_names
+
+if TYPE_CHECKING:
+    from whisperx.asr import FasterWhisperPipeline
 
 import pixeltable as pxt
 
@@ -11,6 +12,36 @@ import pixeltable as pxt
 def transcribe(
     audio: str, *, model: str, compute_type: Optional[str] = None, language: Optional[str] = None, chunk_size: int = 30
 ) -> dict:
+    """
+    Transcribe an audio file using WhisperX.
+
+    This UDF runs a transcription model _locally_ using the WhisperX library,
+    equivalent to the WhisperX `transcribe` function, as described in the
+    [WhisperX library documentation](https://github.com/m-bain/whisperX).
+
+    __Requirements:__
+
+    - `pip install whisperx`
+
+    Args:
+        audio: The audio file to transcribe.
+        model: The name of the model to use for transcription.
+
+    See the [WhisperX library documentation](https://github.com/m-bain/whisperX) for details
+    on the remaining parameters.
+
+    Returns:
+        A dictionary containing the transcription and various other metadata.
+
+    Examples:
+        Add a computed column that applies the model `tiny.en` to an existing Pixeltable column `tbl.audio`
+        of the table `tbl`:
+
+        >>> tbl['result'] = transcribe(tbl.audio, model='tiny.en')
+    """
+    import torch
+    import whisperx
+
     device = 'cuda' if torch.cuda.is_available() else 'cpu'
     compute_type = compute_type or ('float16' if device == 'cuda' else 'int8')
     model = _lookup_model(model, device, compute_type)
@@ -19,7 +50,9 @@ def transcribe(
     return result
 
 
-def _lookup_model(model_id: str, device: str, compute_type: str) -> FasterWhisperPipeline:
+def _lookup_model(model_id: str, device: str, compute_type: str) -> 'FasterWhisperPipeline':
+    import whisperx
+
     key = (model_id, device, compute_type)
     if key not in _model_cache:
         model = whisperx.load_model(model_id, device, compute_type=compute_type)
@@ -28,3 +61,10 @@ def _lookup_model(model_id: str, device: str, compute_type: str) -> FasterWhispe
 
 
 _model_cache = {}
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__():
+    return __all__

pixeltable/ext/functions/yolox.py

@@ -1,20 +1,21 @@
 import logging
 from pathlib import Path
-from typing import Iterable, Iterator
+from typing import Iterable, Iterator, TYPE_CHECKING
 from urllib.request import urlretrieve
 
 import PIL.Image
 import numpy as np
-import torch
-from yolox.data import ValTransform
-from yolox.exp import get_exp, Exp
-from yolox.models import YOLOX
-from yolox.utils import postprocess
 
 import pixeltable as pxt
 from pixeltable import env
 from pixeltable.func import Batch
 from pixeltable.functions.util import normalize_image_mode
+from pixeltable.utils.code import local_public_names
+
+if TYPE_CHECKING:
+    import torch
+    from yolox.exp import Exp
+    from yolox.models import YOLOX
 
 _logger = logging.getLogger('pixeltable')
 
@@ -22,15 +23,32 @@ _logger = logging.getLogger('pixeltable')
 @pxt.udf(batch_size=4)
 def yolox(images: Batch[PIL.Image.Image], *, model_id: str, threshold: float = 0.5) -> Batch[dict]:
     """
-    Runs the specified YOLOX object detection model on an image.
+    Computes YOLOX object detections for the specified image. `model_id` should reference one of the models
+    defined in the [YOLOX documentation](https://github.com/Megvii-BaseDetection/YOLOX).
 
     YOLOX support is part of the `pixeltable.ext` package: long-term support is not guaranteed, and it is not
     intended for use in production applications.
 
-    Parameters:
-    - `model_id` - one of: `yolox_nano, `yolox_tiny`, `yolox_s`, `yolox_m`, `yolox_l`, `yolox_x`
-    - `threshold` - the threshold for object detection
+    __Requirements__:
+
+    - `pip install git+https://github.com/Megvii-BaseDetection/YOLOX`
+
+    Args:
+        model_id: one of: `yolox_nano`, `yolox_tiny`, `yolox_s`, `yolox_m`, `yolox_l`, `yolox_x`
+        threshold: the threshold for object detection
+
+    Returns:
+        A dictionary containing the output of the object detection model.
+
+    Examples:
+        Add a computed column that applies the model `yolox_m` to an existing
+        Pixeltable column `tbl.image` of the table `tbl`:
+
+        >>> tbl['detections'] = yolox(tbl.image, model_id='yolox_m', threshold=0.8)
     """
+    import torch
+    from yolox.utils import postprocess
+
     model, exp = _lookup_model(model_id, 'cpu')
     image_tensors = list(_images_to_tensors(images, exp))
     batch_tensor = torch.stack(image_tensors)
@@ -58,6 +76,21 @@ def yolox(images: Batch[PIL.Image.Image], *, model_id: str, threshold: float = 0
 
 @pxt.udf
 def yolo_to_coco(detections: dict) -> list:
+    """
+    Converts the output of a YOLOX object detection model to COCO format.
+
+    Args:
+        detections: The output of a YOLOX object detection model, as returned by `yolox`.
+
+    Returns:
+        A dictionary containing the data from `detections`, 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'] = yolo_to_coco(tbl.detections)
+    """
     bboxes, labels = detections['bboxes'], detections['labels']
     num_annotations = len(detections['bboxes'])
     assert num_annotations == len(detections['labels'])
@@ -72,14 +105,21 @@ def yolo_to_coco(detections: dict) -> list:
     return result
 
 
-def _images_to_tensors(images: Iterable[PIL.Image.Image], exp: Exp) -> Iterator[torch.Tensor]:
+def _images_to_tensors(images: Iterable[PIL.Image.Image], exp: 'Exp') -> Iterator['torch.Tensor']:
+    import torch
+    from yolox.data import ValTransform
+
+    _val_transform = ValTransform(legacy=False)
     for image in images:
         image = normalize_image_mode(image)
         image_transform, _ = _val_transform(np.array(image), None, exp.test_size)
         yield torch.from_numpy(image_transform)
 
 
-def _lookup_model(model_id: str, device: str) -> (YOLOX, Exp):
+def _lookup_model(model_id: str, device: str) -> tuple['YOLOX', 'Exp']:
+    import torch
+    from yolox.exp import get_exp
+
     key = (model_id, device)
     if key in _model_cache:
         return _model_cache[key]
@@ -105,5 +145,11 @@ def _lookup_model(model_id: str, device: str) -> (YOLOX, Exp):
     return model, exp
 
 
-_model_cache = {}
-_val_transform = ValTransform(legacy=False)
+_model_cache: dict[tuple[str, str], tuple['YOLOX', 'Exp']] = {}
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__():
+    return __all__

pixeltable/func/callable_function.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import Optional, Callable, Tuple, Any
+from typing import Any, Callable, Optional
 from uuid import UUID
 
 import cloudpickle
@@ -19,14 +19,21 @@ class CallableFunction(Function):
     """
 
     def __init__(
-            self, signature: Signature, py_fn: Callable, self_path: Optional[str] = None,
-            self_name: Optional[str] = None, batch_size: Optional[int] = None):
+        self,
+        signature: Signature,
+        py_fn: Callable,
+        self_path: Optional[str] = None,
+        self_name: Optional[str] = None,
+        batch_size: Optional[int] = None,
+        is_method: bool = False,
+        is_property: bool = False
+    ):
         assert py_fn is not None
         self.py_fn = py_fn
         self.self_name = self_name
         self.batch_size = batch_size
         self.__doc__ = py_fn.__doc__
-        super().__init__(signature, self_path=self_path)
+        super().__init__(signature, self_path=self_path, is_method=is_method, is_property=is_property)
 
     @property
     def is_batched(self) -> bool:
@@ -78,6 +85,7 @@ class CallableFunction(Function):
     def _as_dict(self) -> dict:
         if self.self_path is None:
             # this is not a module function
+            assert not self.is_method and not self.is_property
             from .function_registry import FunctionRegistry
             id = FunctionRegistry.get().create_stored_function(self)
             return {'id': id.hex}

pixeltable/func/expr_template_function.py

@@ -56,7 +56,7 @@ class ExprTemplateFunction(Function):
             arg_exprs[param_expr] = arg_expr
         result = result.substitute(arg_exprs)
         import pixeltable.exprs as exprs
-        assert not result.contains(exprs.Variable)
+        assert not result._contains(exprs.Variable)
         return result
 
     def exec(self, *args: Any, **kwargs: Any) -> Any:

pixeltable/func/function.py

@@ -3,10 +3,12 @@ from __future__ import annotations
 import abc
 import importlib
 import inspect
-from typing import Optional, Dict, Any, Tuple, Callable
+from typing import Any, Callable, Dict, Optional, Tuple
 
 import pixeltable
+import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+
 from .globals import resolve_symbol
 from .signature import Signature
 
@@ -19,9 +21,13 @@ class Function(abc.ABC):
     via the member self_path.
     """
 
-    def __init__(self, signature: Signature, self_path: Optional[str] = None):
+    def __init__(self, signature: Signature, self_path: Optional[str] = None, is_method: bool = False, is_property: bool = False):
+        # Check that stored functions cannot be declared using `is_method` or `is_property`:
+        assert not ((is_method or is_property) and self_path is None)
         self.signature = signature
         self.self_path = self_path  # fully-qualified path to self
+        self.is_method = is_method
+        self.is_property = is_property
         self._conditional_return_type: Optional[Callable[..., ts.ColumnType]] = None
 
     @property
@@ -38,6 +44,10 @@ class Function(abc.ABC):
             return self.self_path[len(ptf_prefix):]
         return self.self_path
 
+    @property
+    def arity(self) -> int:
+        return len(self.signature.parameters)
+
     def help_str(self) -> str:
         return self.display_name + str(self.signature)
 

pixeltable/func/function_registry.py

@@ -4,11 +4,9 @@ import dataclasses
 import importlib
 import logging
 import sys
-import types
-from typing import Optional, Dict, List, Tuple
+from typing import Optional, Dict, List
 from uuid import UUID
 
-import cloudpickle
 import sqlalchemy as sql
 
 import pixeltable.env as env
@@ -36,6 +34,7 @@ class FunctionRegistry:
     def __init__(self):
         self.stored_fns_by_id: Dict[UUID, Function] = {}
         self.module_fns: Dict[str, Function] = {}  # fqn -> Function
+        self.type_methods: dict[ts.ColumnType.Type, dict[str, Function]] = {}
 
     def clear_cache(self) -> None:
         """
@@ -69,6 +68,13 @@ class FunctionRegistry:
         if fqn in self.module_fns:
             raise excs.Error(f'A UDF with that name already exists: {fqn}')
         self.module_fns[fqn] = fn
+        if fn.is_method or fn.is_property:
+            base_type = fn.signature.parameters_by_pos[0].col_type.type_enum
+            if base_type not in self.type_methods:
+                self.type_methods[base_type] = {}
+            if fn.name in self.type_methods[base_type]:
+                raise excs.Error(f'Duplicate method name for type {base_type}: {fn.name}')
+            self.type_methods[base_type][fn.name] = fn
 
     def list_functions(self) -> List[Function]:
         # retrieve Function.Metadata data for all existing stored functions from store directly
@@ -129,12 +135,21 @@ class FunctionRegistry:
     #         assert fqn in self.module_fns, f'{fqn} not found'
     #         return self.module_fns[fqn]
 
-    def get_type_methods(self, name: str, base_type: ts.ColumnType.Type) -> List[Function]:
-        return [
-            fn for fn in self.module_fns.values()
-            if fn.self_path is not None and fn.self_path.endswith('.' + name) \
-               and fn.signature.parameters_by_pos[0].col_type.type_enum == base_type
-        ]
+    def get_type_methods(self, base_type: ts.ColumnType.Type) -> list[Function]:
+        """
+        Get a list of all methods (and properties) registered for a given base type.
+        """
+        if base_type in self.type_methods:
+            return list(self.type_methods[base_type].values())
+        return []
+
+    def lookup_type_method(self, base_type: ts.ColumnType.Type, name: str) -> Optional[Function]:
+        """
+        Look up a method (or property) by name for a given base type. If no such method is registered, return None.
+        """
+        if base_type in self.type_methods and name in self.type_methods[base_type]:
+            return self.type_methods[base_type][name]
+        return None
 
     #def create_function(self, md: schema.FunctionMd, binary_obj: bytes, dir_id: Optional[UUID] = None) -> UUID:
     def create_stored_function(self, pxt_fn: Function, dir_id: Optional[UUID] = None) -> UUID:

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, json, vision
 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}