learning-loop-node 0.10.17__tar.gz → 0.11.0__tar.gz

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learning-loop-node
-Version: 0.10.17
+Version: 0.11.0
 Summary: Python Library for Nodes which connect to the Zauberzeug Learning Loop
 Home-page: https://github.com/zauberzeug/learning_loop_node
 License: MIT

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/data_classes/__init__.py

@@ -3,14 +3,15 @@ from .detections import (BoxDetection, ClassificationDetection, Detections, Obse
                          SegmentationDetection, Shape)
 from .general import (AnnotationNodeStatus, Category, CategoryType, Context, DetectionStatus, ErrorConfiguration,
                       ModelInformation, NodeState, NodeStatus)
+from .image_metadata import ImageMetadata
 from .socket_response import SocketResponse
 from .training import (Errors, Hyperparameter, Model, PretrainedModel, TrainerState, Training, TrainingData,
                        TrainingError, TrainingOut, TrainingStateData, TrainingStatus)
 
 __all__ = [
     'AnnotationData', 'AnnotationEventType', 'SegmentationAnnotation', 'ToolOutput', 'UserInput',
-    'BoxDetection', 'ClassificationDetection', 'Detections', 'Observation', 'Point', 'PointDetection',
-    'SegmentationDetection', 'Shape',
+    'BoxDetection', 'ClassificationDetection', 'ImageMetadata', 'Observation', 'Point', 'PointDetection',
+    'SegmentationDetection', 'Shape', 'Detections',
     'AnnotationNodeStatus', 'Category', 'CategoryType', 'Context', 'DetectionStatus', 'ErrorConfiguration',
     'ModelInformation', 'NodeState', 'NodeStatus',
     'SocketResponse',

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/data_classes/detections.py

@@ -6,11 +6,13 @@ from typing import List, Optional, Union
 
 import numpy as np
 
-# pylint: disable=too-many-instance-attributes
-
 KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
 
 
+def current_datetime():
+    return datetime.now().isoformat(sep='_', timespec='milliseconds')
+
+
 @dataclass(**KWONLY_SLOTS)
 class BoxDetection():
     """Coordinates according to COCO format. x,y is the top left corner of the box.
@@ -106,10 +108,6 @@ class SegmentationDetection():
         return f'shape:{str(self.shape)}, c: {self.confidence:.2f} -> {self.category_name}'
 
 
-def current_datetime():
-    return datetime.now().isoformat(sep='_', timespec='milliseconds')
-
-
 @dataclass(**KWONLY_SLOTS)
 class Detections():
     box_detections: List[BoxDetection] = field(default_factory=list, metadata={
@@ -120,14 +118,9 @@ class Detections():
         'description': 'List of segmentation detections'})
     classification_detections: List[ClassificationDetection] = field(default_factory=list, metadata={
         'description': 'List of classification detections'})
-    tags: List[str] = field(default_factory=list, metadata={
-        'description': 'List of tags'})
-    date: Optional[str] = field(default_factory=current_datetime, metadata={
-        'description': 'Date of the detections'})
+
     image_id: Optional[str] = field(default=None, metadata={
         'description': 'Image uuid'})
-    source: Optional[str] = field(default=None, metadata={
-        'description': 'Source of the detections'})
 
     def __len__(self):
         return len(self.box_detections) + len(self.point_detections) + len(self.segmentation_detections) + len(self.classification_detections)

learning_loop_node-0.11.0/learning_loop_node/data_classes/image_metadata.py

@@ -0,0 +1,37 @@
+
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import List, Optional
+
+from .detections import BoxDetection, ClassificationDetection, PointDetection, SegmentationDetection
+
+# pylint: disable=too-many-instance-attributes
+
+KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
+
+
+def current_datetime():
+    return datetime.now().isoformat(sep='_', timespec='milliseconds')
+
+
+@dataclass(**KWONLY_SLOTS)
+class ImageMetadata():
+    box_detections: List[BoxDetection] = field(default_factory=list, metadata={
+        'description': 'List of box detections'})
+    point_detections: List[PointDetection] = field(default_factory=list, metadata={
+        'description': 'List of point detections'})
+    segmentation_detections: List[SegmentationDetection] = field(default_factory=list, metadata={
+        'description': 'List of segmentation detections'})
+    classification_detections: List[ClassificationDetection] = field(default_factory=list, metadata={
+        'description': 'List of classification detections'})
+    tags: List[str] = field(default_factory=list, metadata={
+        'description': 'List of tags'})
+
+    date: Optional[str] = field(default_factory=current_datetime, metadata={
+        'description': 'Creation date of the image'})
+    source: Optional[str] = field(default=None, metadata={
+        'description': 'Source of the image'})
+
+    def __len__(self):
+        return len(self.box_detections) + len(self.point_detections) + len(self.segmentation_detections) + len(self.classification_detections)

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/detector/detector_logic.py

@@ -4,7 +4,7 @@ from typing import List, Optional
 
 import numpy as np
 
-from ..data_classes import Detections, ModelInformation
+from ..data_classes import ImageMetadata, ModelInformation
 from ..globals import GLOBALS
 
 
@@ -46,13 +46,13 @@ class DetectorLogic():
     def init(self):
         """Called when a (new) model was loaded. Initialize the model. Model information available via `self.model_info`"""
 
-    def evaluate_with_all_info(self, image: np.ndarray, tags: List[str], source: Optional[str] = None) -> Detections:  # pylint: disable=unused-argument
+    def evaluate_with_all_info(self, image: np.ndarray, tags: List[str], source: Optional[str] = None, creation_date: Optional[str] = None) -> ImageMetadata:  # pylint: disable=unused-argument
         """Called by the detector node when an image should be evaluated (REST or SocketIO).
         Tags, source come from the caller and may be used in this function. 
         By default, this function simply calls `evaluate`"""
         return self.evaluate(image)
 
     @abstractmethod
-    def evaluate(self, image: np.ndarray) -> Detections:
+    def evaluate(self, image: np.ndarray) -> ImageMetadata:
         """Evaluate the image and return the detections.
         The object should return empty detections if it is not initialized"""

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/detector/detector_node.py

@@ -14,7 +14,7 @@ from dacite import from_dict
 from fastapi.encoders import jsonable_encoder
 from socketio import AsyncClient
 
-from ..data_classes import Category, Context, Detections, DetectionStatus, ModelInformation, Shape
+from ..data_classes import Category, Context, DetectionStatus, ImageMetadata, ModelInformation, Shape
 from ..data_classes.socket_response import SocketResponse
 from ..data_exchanger import DataExchanger, DownloadError
 from ..globals import GLOBALS
@@ -174,22 +174,23 @@ class DetectorNode(Node):
             detection_data = data.get('detections', {})
             if detection_data and self.detector_logic.is_initialized:
                 try:
-                    detections = from_dict(data_class=Detections, data=detection_data)
+                    image_metadata = from_dict(data_class=ImageMetadata, data=detection_data)
                 except Exception as e:
                     self.log.exception('could not parse detections')
                     return {'error': str(e)}
-                detections = self.add_category_id_to_detections(self.detector_logic.model_info, detections)
+                image_metadata = self.add_category_id_to_detections(self.detector_logic.model_info, image_metadata)
             else:
-                detections = Detections()
+                image_metadata = ImageMetadata()
 
             tags = data.get('tags', [])
             tags.append('picked_by_system')
 
             source = data.get('source', None)
+            creation_date = data.get('creation_date', None)
 
             loop = asyncio.get_event_loop()
             try:
-                await loop.run_in_executor(None, self.outbox.save, data['image'], detections, tags, source)
+                await loop.run_in_executor(None, self.outbox.save, data['image'], image_metadata, tags, source, creation_date)
             except Exception as e:
                 self.log.exception('could not upload via socketio')
                 return {'error': str(e)}
@@ -343,7 +344,8 @@ class DetectorNode(Node):
                              camera_id: Optional[str],
                              tags: List[str],
                              source: Optional[str] = None,
-                             autoupload: Optional[str] = None) -> Detections:
+                             autoupload: Optional[str] = None,
+                             creation_date: Optional[str] = None) -> ImageMetadata:
         """ Main processing function for the detector node when an image is received via REST or SocketIO.
         This function infers the detections from the image, cares about uploading to the loop and returns the detections as a dictionary.
         Note: raw_image is a numpy array of type uint8, but not in the correct shape!
@@ -351,7 +353,7 @@ class DetectorNode(Node):
 
         await self.detection_lock.acquire()
         loop = asyncio.get_event_loop()
-        detections = await loop.run_in_executor(None, self.detector_logic.evaluate_with_all_info, raw_image, tags, source)
+        detections = await loop.run_in_executor(None, self.detector_logic.evaluate_with_all_info, raw_image, tags, source, creation_date)
         self.detection_lock.release()
 
         fix_shape_detections(detections)
@@ -361,42 +363,42 @@ class DetectorNode(Node):
 
         if autoupload is None or autoupload == 'filtered':  # NOTE default is filtered
             Thread(target=self.relevance_filter.may_upload_detections,
-                   args=(detections, camera_id, raw_image, tags, source)).start()
+                   args=(detections, camera_id, raw_image, tags, source, creation_date)).start()
         elif autoupload == 'all':
-            Thread(target=self.outbox.save, args=(raw_image, detections, tags, source)).start()
+            Thread(target=self.outbox.save, args=(raw_image, detections, tags, source, creation_date)).start()
         elif autoupload == 'disabled':
             pass
         else:
             self.log.error('unknown autoupload value %s', autoupload)
         return detections
 
-    async def upload_images(self, images: List[bytes]):
+    async def upload_images(self, images: List[bytes], source: Optional[str], creation_date: Optional[str]):
         loop = asyncio.get_event_loop()
         for image in images:
-            await loop.run_in_executor(None, self.outbox.save, image, Detections(), ['picked_by_system'])
+            await loop.run_in_executor(None, self.outbox.save, image, ImageMetadata(), ['picked_by_system'], source, creation_date)
 
-    def add_category_id_to_detections(self, model_info: ModelInformation, detections: Detections):
+    def add_category_id_to_detections(self, model_info: ModelInformation, image_metadata: ImageMetadata):
         def find_category_id_by_name(categories: List[Category], category_name: str):
             category_id = [category.id for category in categories if category.name == category_name]
             return category_id[0] if category_id else ''
 
-        for box_detection in detections.box_detections:
+        for box_detection in image_metadata.box_detections:
             category_name = box_detection.category_name
             category_id = find_category_id_by_name(model_info.categories, category_name)
             box_detection.category_id = category_id
-        for point_detection in detections.point_detections:
+        for point_detection in image_metadata.point_detections:
             category_name = point_detection.category_name
             category_id = find_category_id_by_name(model_info.categories, category_name)
             point_detection.category_id = category_id
-        for segmentation_detection in detections.segmentation_detections:
+        for segmentation_detection in image_metadata.segmentation_detections:
             category_name = segmentation_detection.category_name
             category_id = find_category_id_by_name(model_info.categories, category_name)
             segmentation_detection.category_id = category_id
-        for classification_detection in detections.classification_detections:
+        for classification_detection in image_metadata.classification_detections:
             category_name = classification_detection.category_name
             category_id = find_category_id_by_name(model_info.categories, category_name)
             classification_detection.category_id = category_id
-        return detections
+        return image_metadata
 
     def register_sio_events(self, sio_client: AsyncClient):
         pass
@@ -412,7 +414,7 @@ def step_into(new_dir):
         os.chdir(previous_dir)
 
 
-def fix_shape_detections(detections: Detections):
+def fix_shape_detections(detections: ImageMetadata):
     # TODO This is a quick fix.. check how loop upload detections deals with this
     for seg_detection in detections.segmentation_detections:
         if isinstance(seg_detection.shape, Shape):

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/detector/inbox_filter/cam_observation_history.py

@@ -1,7 +1,7 @@
 import os
 from typing import List, Union
 
-from learning_loop_node.data_classes import (BoxDetection, ClassificationDetection, Detections, Observation,
+from learning_loop_node.data_classes import (BoxDetection, ClassificationDetection, ImageMetadata, Observation,
                                              PointDetection, SegmentationDetection)
 
 
@@ -16,9 +16,9 @@ class CamObservationHistory:
                                     for detection in self.recent_observations
                                     if not detection.is_older_than(self.reset_time)]
 
-    def get_causes_to_upload(self, detections: Detections) -> List[str]:
+    def get_causes_to_upload(self, image_metadata: ImageMetadata) -> List[str]:
         causes = set()
-        for detection in detections.box_detections + detections.point_detections + detections.segmentation_detections + detections.classification_detections:
+        for detection in image_metadata.box_detections + image_metadata.point_detections + image_metadata.segmentation_detections + image_metadata.classification_detections:
             if isinstance(detection, SegmentationDetection):
                 # self.recent_observations.append(Observation(detection))
                 causes.add('segmentation_detection')

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/detector/inbox_filter/relevance_filter.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Optional
 
-from ...data_classes.detections import Detections
+from ...data_classes.image_metadata import ImageMetadata
 from ..outbox import Outbox
 from .cam_observation_history import CamObservationHistory
 
@@ -12,22 +12,23 @@ class RelevanceFilter():
         self.outbox: Outbox = outbox
 
     def may_upload_detections(self,
-                              dets: Detections,
+                              image_metadata: ImageMetadata,
                               cam_id: str,
                               raw_image: bytes,
                               tags: List[str],
-                              source: Optional[str] = None
+                              source: Optional[str] = None,
+                              creation_date: Optional[str] = None
                               ) -> List[str]:
         for group in self.cam_histories.values():
             group.forget_old_detections()
 
         if cam_id not in self.cam_histories:
             self.cam_histories[cam_id] = CamObservationHistory()
-        causes = self.cam_histories[cam_id].get_causes_to_upload(dets)
-        if len(dets) >= 80:
+        causes = self.cam_histories[cam_id].get_causes_to_upload(image_metadata)
+        if len(image_metadata) >= 80:
             causes.append('unexpected_observations_count')
         if len(causes) > 0:
             tags = tags if tags is not None else []
             tags.extend(causes)
-            self.outbox.save(raw_image, dets, tags, source)
+            self.outbox.save(raw_image, image_metadata, tags, source, creation_date)
         return causes

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/detector/outbox.py

@@ -19,7 +19,7 @@ import PIL
 import PIL.Image  # type: ignore
 from fastapi.encoders import jsonable_encoder
 
-from ..data_classes import Detections
+from ..data_classes import ImageMetadata
 from ..globals import GLOBALS
 from ..helpers import environment_reader
 
@@ -56,17 +56,18 @@ class Outbox():
 
     def save(self,
              image: bytes,
-             detections: Optional[Detections] = None,
+             image_metadata: Optional[ImageMetadata] = None,
              tags: Optional[List[str]] = None,
-             source: Optional[str] = None
+             source: Optional[str] = None,
+             creation_date: Optional[str] = None
              ) -> None:
 
         if not self._is_valid_jpg(image):
             self.log.error('Invalid jpg image')
             return
 
-        if detections is None:
-            detections = Detections()
+        if image_metadata is None:
+            image_metadata = ImageMetadata()
         if not tags:
             tags = []
         identifier = datetime.now().isoformat(sep='_', timespec='microseconds')
@@ -74,13 +75,16 @@ class Outbox():
             self.log.error('Directory with identifier %s already exists', identifier)
             return
         tmp = f'{GLOBALS.data_folder}/tmp/{identifier}'
-        detections.tags = tags
-        detections.date = identifier
-        detections.source = source or 'unknown'
+        image_metadata.tags = tags
+        if creation_date and self._is_valid_isoformat(creation_date):
+            image_metadata.date = creation_date
+        else:
+            image_metadata.date = identifier
+        image_metadata.source = source or 'unknown'
         os.makedirs(tmp, exist_ok=True)
 
         with open(tmp + '/image.json', 'w') as f:
-            json.dump(jsonable_encoder(asdict(detections)), f)
+            json.dump(jsonable_encoder(asdict(image_metadata)), f)
 
         with open(tmp + '/image.jpg', 'wb') as f:
             f.write(image)
@@ -90,6 +94,13 @@ class Outbox():
         else:
             self.log.error('Could not rename %s to %s', tmp, self.path + '/' + identifier)
 
+    def _is_valid_isoformat(self, date: str) -> bool:
+        try:
+            datetime.fromisoformat(date)
+            return True
+        except Exception:
+            return False
+
     def get_data_files(self):
         return glob(f'{self.path}/*')
 

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/detector/rest/detect.py

@@ -3,9 +3,8 @@ from typing import TYPE_CHECKING, Optional
 
 import numpy as np
 from fastapi import APIRouter, File, Header, Request, UploadFile
-from fastapi.responses import JSONResponse
 
-from ...data_classes.detections import Detections
+from ...data_classes.image_metadata import ImageMetadata
 
 if TYPE_CHECKING:
     from ..detector_node import DetectorNode
@@ -13,7 +12,7 @@ if TYPE_CHECKING:
 router = APIRouter()
 
 
-@router.post("/detect", response_model=Detections)
+@router.post("/detect", response_model=ImageMetadata)
 async def http_detect(
     request: Request,
     file: UploadFile = File(..., description='The image file to run detection on'),
@@ -23,6 +22,7 @@ async def http_detect(
     source: Optional[str] = Header(None, description='The source of the image (used by learning loop)'),
     autoupload: Optional[str] = Header(None, description='Mode to decide whether to upload the image to the learning loop',
                                        examples=['filtered', 'all', 'disabled']),
+    creation_date: Optional[str] = Header(None, description='The creation date of the image (used by learning loop)')
 ):
     """
     Single image example:
@@ -46,7 +46,8 @@ async def http_detect(
                                               camera_id=camera_id or mac or None,
                                               tags=tags.split(',') if tags else [],
                                               source=source,
-                                              autoupload=autoupload)
+                                              autoupload=autoupload,
+                                              creation_date=creation_date)
     except Exception as exc:
         logging.exception('Error during detection of image %s.', file.filename)
         raise Exception(f'Error during detection of image {file.filename}.') from exc

learning_loop_node-0.11.0/learning_loop_node/detector/rest/upload.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from fastapi import APIRouter, File, Query, Request, UploadFile
+
+if TYPE_CHECKING:
+    from ..detector_node import DetectorNode
+
+router = APIRouter()
+
+
+@router.post("/upload")
+async def upload_image(request: Request,
+                       files: List[UploadFile] = File(...),
+                       source: Optional[str] = Query(None, description='Source of the image'),
+                       creation_date: Optional[str] = Query(None, description='Creation date of the image')):
+    """
+    Upload an image or multiple images to the learning loop.
+
+    The image source and the image creation date are optional query parameters.
+    Images are automatically tagged with 'picked_by_system'.
+
+    Example Usage
+
+        curl -X POST -F 'files=@test.jpg' "http://localhost:/upload?source=test&creation_date=2024-01-01T00:00:00"
+    """
+    raw_files = [await file.read() for file in files]
+    node: DetectorNode = request.app
+    await node.upload_images(raw_files, source, creation_date)
+    return 200, "OK"

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/tests/detector/conftest.py

@@ -6,13 +6,14 @@ import shutil
 import socket
 from glob import glob
 from multiprocessing import Process, log_to_stderr
-from typing import AsyncGenerator
+from typing import AsyncGenerator, List, Optional
 
+import numpy as np
 import pytest
 import socketio
 import uvicorn
 
-from learning_loop_node.data_classes import BoxDetection, Detections
+from learning_loop_node.data_classes import BoxDetection, ImageMetadata
 from learning_loop_node.detector.detector_logic import DetectorLogic
 
 from ...detector.detector_node import DetectorNode
@@ -100,8 +101,8 @@ async def sio_client() -> AsyncGenerator[socketio.AsyncClient, None]:
         try:
             await sio.connect(f"ws://localhost:{detector_port}", socketio_path="/ws/socket.io")
             try_connect = False
-        except Exception as e:
-            logging.warning(f"Connection failed with error: {str(e)}")
+        except Exception:
+            logging.exception("Connection failed with error:")
             logging.warning('trying again')
             await asyncio.sleep(5)
         retry_count += 1
@@ -122,21 +123,20 @@ def mock_detector_logic():
     class MockDetectorLogic(DetectorLogic):  # pylint: disable=abstract-method
         def __init__(self):
             super().__init__('mock')
-            self.detections = Detections(
+            self.image_metadata = ImageMetadata(
                 box_detections=[BoxDetection(category_name="test",
                                              category_id="1",
                                              confidence=0.9,
                                              x=0, y=0, width=10, height=10,
                                              model_name="mock",
-                                             )]
-            )
+                                             )])
 
         @property
         def is_initialized(self):
             return True
 
-        def evaluate_with_all_info(self, image, tags, source):  # pylint: disable=signature-differs
-            return self.detections
+        def evaluate_with_all_info(self, image: np.ndarray, tags: List[str], source: Optional[str] = None, creation_date: Optional[str] = None):
+            return self.image_metadata
 
     return MockDetectorLogic()
 

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/tests/detector/inbox_filter/test_relevance_group.py

@@ -5,7 +5,7 @@ from typing import List
 
 from dacite import from_dict
 
-from ....data_classes.detections import BoxDetection, Detections, Point, PointDetection, SegmentationDetection, Shape
+from ....data_classes import BoxDetection, ImageMetadata, Point, PointDetection, SegmentationDetection, Shape
 from ....detector.inbox_filter.cam_observation_history import CamObservationHistory
 
 dirt_detection = BoxDetection(category_name='dirt', x=0, y=0, width=100, height=100,
@@ -18,16 +18,16 @@ conf_too_low_detection = BoxDetection(category_name='dirt', x=0, y=0, width=100,
                                       height=100, category_id='xyz', model_name='test_model', confidence=.29)
 
 
-def det_from_boxes(box_detections: List[BoxDetection]) -> Detections:
-    return Detections(box_detections=box_detections)
+def det_from_boxes(box_detections: List[BoxDetection]) -> ImageMetadata:
+    return ImageMetadata(box_detections=box_detections)
 
 
-def det_from_points(point_detections: List[PointDetection]) -> Detections:
-    return Detections(point_detections=point_detections)
+def det_from_points(point_detections: List[PointDetection]) -> ImageMetadata:
+    return ImageMetadata(point_detections=point_detections)
 
 
-def det_from_seg(seg_detections: List[SegmentationDetection]) -> Detections:
-    return Detections(segmentation_detections=seg_detections)
+def det_from_seg(seg_detections: List[SegmentationDetection]) -> ImageMetadata:
+    return ImageMetadata(segmentation_detections=seg_detections)
 
 
 def test_group_confidence():

{learning_loop_node-0.10.17 → learning_loop_node-0.11.0}/learning_loop_node/tests/detector/inbox_filter/test_unexpected_observations_count.py

@@ -3,7 +3,7 @@ from typing import List
 
 import pytest
 
-from ....data_classes.detections import BoxDetection, Detections, PointDetection
+from ....data_classes.image_metadata import BoxDetection, ImageMetadata, PointDetection
 from ....detector.inbox_filter.relevance_filter import RelevanceFilter
 from ....detector.outbox import Outbox
 
@@ -17,14 +17,14 @@ l_conf_point_det = PointDetection(category_name='point', x=100, y=100,
 
 @pytest.mark.parametrize(
     "detections,reason",
-    [(Detections(box_detections=[h_conf_box_det] * 40, point_detections=[h_conf_point_det] * 40),
+    [(ImageMetadata(box_detections=[h_conf_box_det] * 40, point_detections=[h_conf_point_det] * 40),
       ['unexpected_observations_count']),
-     (Detections(box_detections=[h_conf_box_det], point_detections=[h_conf_point_det]), []),
-     (Detections(box_detections=[h_conf_box_det] * 40, point_detections=[l_conf_point_det] * 40),
+     (ImageMetadata(box_detections=[h_conf_box_det], point_detections=[h_conf_point_det]), []),
+     (ImageMetadata(box_detections=[h_conf_box_det] * 40, point_detections=[l_conf_point_det] * 40),
       ['uncertain', 'unexpected_observations_count']),
-     (Detections(box_detections=[h_conf_box_det], point_detections=[l_conf_point_det]),
+     (ImageMetadata(box_detections=[h_conf_box_det], point_detections=[l_conf_point_det]),
       ['uncertain'])])
-def test_unexpected_observations_count(detections: Detections, reason: List[str]):
+def test_unexpected_observations_count(detections: ImageMetadata, reason: List[str]):
     os.environ['LOOP_ORGANIZATION'] = 'zauberzeug'
     os.environ['LOOP_PROJECT'] = 'demo'
     outbox = Outbox()