learning-loop-node 0.16.1__py3-none-any.whl → 0.17.0__py3-none-any.whl

learning_loop_node/data_classes/__init__.py

@@ -1,4 +1,9 @@
-from .annotations import AnnotationData, SegmentationAnnotation, ToolOutput, UserInput
+from .annotation_data import (
+    AnnotationData,
+    SegmentationAnnotation,
+    ToolOutput,
+    UserInput,
+)
 from .detections import (
     BoxDetection,
     ClassificationDetection,

learning_loop_node/data_classes/annotation_data.py

@@ -0,0 +1,43 @@
+import sys
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from ..enums import AnnotationEventType
+from .detections import Point, Shape
+from .general import Category, Context
+
+KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
+
+
+@dataclass(**KWONLY_SLOTS)
+class AnnotationData():
+    coordinate: Point
+    event_type: Union[AnnotationEventType, str]
+    context: Context
+    image_uuid: str
+    category: Category
+
+    key_up: Optional[str] = None
+    key_down: Optional[str] = None
+    epsilon: Optional[float] = None
+    is_shift_key_pressed: Optional[bool] = None
+
+
+@dataclass(**KWONLY_SLOTS)
+class SegmentationAnnotation():
+    id: str
+    shape: Shape
+    image_id: str
+    category_id: str
+
+
+@dataclass(**KWONLY_SLOTS)
+class UserInput():
+    frontend_id: str
+    data: AnnotationData
+
+
+@dataclass(**KWONLY_SLOTS)
+class ToolOutput():
+    svg: str
+    annotation: Optional[SegmentationAnnotation] = None

learning_loop_node/data_classes/annotations.py

@@ -1,43 +1,44 @@
-import sys
-from dataclasses import dataclass
-from typing import Optional, Union
 
-from ..enums import AnnotationEventType
-from .detections import Point, Shape
-from .general import Category, Context
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
 
 KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
 
 
 @dataclass(**KWONLY_SLOTS)
-class AnnotationData():
-    coordinate: Point
-    event_type: Union[AnnotationEventType, str]
-    context: Context
-    image_uuid: str
-    category: Category
+class BoxAnnotation():
+    """Coordinates according to COCO format. x,y is the top left corner of the box.
+    x increases to the right, y increases downwards.
+    """
+    category_name: str = field(metadata={'description': 'Category name'})
+    x: int = field(metadata={'description': 'X coordinate (left to right)'})
+    y: int = field(metadata={'description': 'Y coordinate (top to bottom)'})
+    width: int = field(metadata={'description': 'Width'})
+    height: int = field(metadata={'description': 'Height'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
 
-    key_up: Optional[str] = None
-    key_down: Optional[str] = None
-    epsilon: Optional[float] = None
-    is_shift_key_pressed: Optional[bool] = None
+    def __str__(self):
+        return f'x:{int(self.x)} y: {int(self.y)}, w: {int(self.width)} h: {int(self.height)} -> {self.category_name}'
 
 
 @dataclass(**KWONLY_SLOTS)
-class SegmentationAnnotation():
-    id: str
-    shape: Shape
-    image_id: str
-    category_id: str
+class PointAnnotation():
+    """Coordinates according to COCO format. x,y is the center of the point.
+    x increases to the right, y increases downwards."""
+    category_name: str = field(metadata={'description': 'Category name'})
+    x: float = field(metadata={'description': 'X coordinate (right)'})
+    y: float = field(metadata={'description': 'Y coordinate (down)'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
 
-
-@dataclass(**KWONLY_SLOTS)
-class UserInput():
-    frontend_id: str
-    data: AnnotationData
+    def __str__(self):
+        return f'x:{int(self.x)} y: {int(self.y)}, -> {self.category_name}'
 
 
 @dataclass(**KWONLY_SLOTS)
-class ToolOutput():
-    svg: str
-    annotation: Optional[SegmentationAnnotation] = None
+class ClassificationAnnotation():
+    category_name: str = field(metadata={'description': 'Category name'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
+
+    def __str__(self):
+        return f'-> {self.category_name}'

learning_loop_node/data_classes/detections.py

@@ -9,10 +9,6 @@ import numpy as np
 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.
@@ -25,7 +21,7 @@ class BoxDetection():
     height: int = field(metadata={'description': 'Height'})
     model_name: str = field(metadata={'description': 'Model name'})
     confidence: float = field(metadata={'description': 'Confidence'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category ID'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
 
     def intersection_over_union(self, other_detection: 'BoxDetection') -> float:
         # https://www.pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/
@@ -59,7 +55,7 @@ class PointDetection():
     y: float = field(metadata={'description': 'Y coordinate (down)'})
     model_name: str = field(metadata={'description': 'Model name'})
     confidence: float = field(metadata={'description': 'Confidence'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category ID'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
 
     def distance(self, other: 'PointDetection') -> float:
         return np.sqrt((other.x - self.x)**2 + (other.y - self.y)**2)
@@ -73,7 +69,7 @@ class ClassificationDetection():
     category_name: str = field(metadata={'description': 'Category name'})
     model_name: str = field(metadata={'description': 'Model name'})
     confidence: float = field(metadata={'description': 'Confidence'})
-    category_id: Optional[str] = field(default=None, metadata={'description': 'Category ID'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category UUID'})
 
     def __str__(self):
         return f'c: {self.confidence:.2f} -> {self.category_name}'

learning_loop_node/data_classes/image_metadata.py

@@ -4,7 +4,13 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import List, Optional
 
-from .detections import BoxDetection, ClassificationDetection, PointDetection, SegmentationDetection
+from .annotations import BoxAnnotation, ClassificationAnnotation, PointAnnotation
+from .detections import (
+    BoxDetection,
+    ClassificationDetection,
+    PointDetection,
+    SegmentationDetection,
+)
 
 # pylint: disable=too-many-instance-attributes
 
@@ -25,6 +31,14 @@ class ImageMetadata():
         'description': 'List of segmentation detections'})
     classification_detections: List[ClassificationDetection] = field(default_factory=list, metadata={
         'description': 'List of classification detections'})
+
+    box_annotations: List[BoxAnnotation] = field(default_factory=list, metadata={
+        'description': 'List of box annotations'})
+    point_annotations: List[PointAnnotation] = field(default_factory=list, metadata={
+        'description': 'List of point annotations'})
+    classification_annotation: Optional[ClassificationAnnotation] = field(default=None, metadata={
+        'description': 'Classification annotation'})
+
     tags: List[str] = field(default_factory=list, metadata={
         'description': 'List of tags'})
 

learning_loop_node/detector/detector_logic.py

@@ -42,18 +42,18 @@ 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: bytes, 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: bytes) -> ImageMetadata:
+    def evaluate(self, image: bytes) -> ImageMetadata:  # pylint: disable=unused-argument
         """Evaluate the image and return the detections.
-        The object should return empty detections if it is not initialized"""
+
+        Called by the detector node when an image should be evaluated (REST or SocketIO).
+        The resulting detections should be stored in the ImageMetadata.
+        Tags stored in the ImageMetadata will be uploaded to the learning loop.
+        The function should return empty metadata if the detector is not initialized."""
 
     @abstractmethod
     def batch_evaluate(self, images: List[bytes]) -> ImagesMetadata:
         """Evaluate a batch of images and return the detections.
-        The object should return empty detections if it is not initialized"""
+        The resulting detections per image should be stored in the ImagesMetadata.
+        Tags stored in the ImagesMetadata will be uploaded to the learning loop.
+        The function should return empty metadata if the detector is not initialized."""

learning_loop_node/detector/detector_node.py

@@ -8,6 +8,11 @@ from dataclasses import asdict
 from datetime import datetime
 from typing import Dict, List, Optional
 
+try:
+    from typing import Literal
+except ImportError:  # Python <= 3.8
+    from typing_extensions import Literal  # type: ignore
+
 import socketio
 from dacite import from_dict
 from fastapi.encoders import jsonable_encoder
@@ -223,10 +228,10 @@ class DetectorNode(Node):
             try:
                 det = await self.get_detections(
                     raw_image=data['image'],
-                    camera_id=data.get('camera-id', None) or data.get('mac', None),
+                    camera_id=data.get('camera_id', None),
                     tags=data.get('tags', []),
                     source=data.get('source', None),
-                    autoupload=data.get('autoupload', None),
+                    autoupload=data.get('autoupload', 'filtered'),
                     creation_date=data.get('creation_date', None)
                 )
                 if det is None:
@@ -245,9 +250,9 @@ class DetectorNode(Node):
                 det = await self.get_batch_detections(
                     raw_images=data['images'],
                     tags=data.get('tags', []),
-                    camera_id=data.get('camera-id', None) or data.get('mac', None),
+                    camera_id=data.get('camera_id', None),
                     source=data.get('source', None),
-                    autoupload=data.get('autoupload', None),
+                    autoupload=data.get('autoupload', 'filtered'),
                     creation_date=data.get('creation_date', None)
                 )
                 if det is None:
@@ -296,27 +301,30 @@ class DetectorNode(Node):
 
         @self.sio.event
         async def upload(sid, data: Dict) -> Dict:
-            """Upload an image with detections"""
+            """Upload a single image with metadata to the learning loop.
 
+            The data dict must contain:
+            - image: The image bytes to upload
+            - metadata: The metadata for the image (optional)
+            """
             self.log.debug('Processing upload via socketio.')
-            detection_data = data.get('detections', {})
-            if detection_data and self.detector_logic.model_info is not None:
+
+            metadata = data.get('metadata', None)
+            if metadata:
                 try:
-                    image_metadata = from_dict(data_class=ImageMetadata, data=detection_data)
+                    image_metadata = from_dict(data_class=ImageMetadata, data=metadata)
                 except Exception as e:
                     self.log.exception('could not parse detections')
                     return {'error': str(e)}
-                image_metadata = self.add_category_id_to_detections(self.detector_logic.model_info, image_metadata)
+                if self.detector_logic.model_info is not None:
+                    image_metadata = self.add_category_id_to_detections(self.detector_logic.model_info, image_metadata)
             else:
                 image_metadata = ImageMetadata()
 
             try:
                 await self.upload_images(
                     images=[data['image']],
-                    image_metadata=image_metadata,
-                    tags=data.get('tags', []),
-                    source=data.get('source', None),
-                    creation_date=data.get('creation_date', None),
+                    images_metadata=ImagesMetadata(items=[image_metadata]) if metadata else None,
                     upload_priority=data.get('upload_priority', False)
                 )
             except Exception as e:
@@ -506,34 +514,34 @@ class DetectorNode(Node):
                              *,
                              camera_id: Optional[str] = None,
                              source: Optional[str] = None,
-                             autoupload: Optional[str] = None,
+                             autoupload: Literal['filtered', 'all', 'disabled'],
                              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 ImageMetadata object.
         Note: raw_image is a numpy array of type uint8, but not in the correct shape!
-        It can be converted e.g. using cv2.imdecode(raw_image, cv2.IMREAD_COLOR)"""
+        It can be converted e.g. using cv2.imdecode(np.frombuffer(image, np.uint8), cv2.IMREAD_COLOR)"""
 
         await self.detection_lock.acquire()
-        detections = await run.io_bound(self.detector_logic.evaluate_with_all_info, raw_image, tags, source, creation_date)
+        metadata = await run.io_bound(self.detector_logic.evaluate, raw_image)
+        metadata.tags.extend(tags)
+        metadata.source = source
+        metadata.created = creation_date
         self.detection_lock.release()
 
-        fix_shape_detections(detections)
-        n_bo, n_cl = len(detections.box_detections), len(detections.classification_detections)
-        n_po, n_se = len(detections.point_detections), len(detections.segmentation_detections)
+        fix_shape_detections(metadata)
+        n_bo, n_cl = len(metadata.box_detections), len(metadata.classification_detections)
+        n_po, n_se = len(metadata.point_detections), len(metadata.segmentation_detections)
         self.log.debug('Detected: %d boxes, %d points, %d segs, %d classes', n_bo, n_po, n_se, n_cl)
 
-        autoupload = autoupload or 'filtered'
-        if autoupload == 'filtered' and camera_id is not None:
-            background_tasks.create(self.relevance_filter.may_upload_detections(
-                detections, camera_id, raw_image, tags, source, creation_date
-            ))
+        if autoupload == 'filtered':
+            background_tasks.create(self.relevance_filter.may_upload_detections(metadata, camera_id, raw_image))
         elif autoupload == 'all':
-            background_tasks.create(self.outbox.save(raw_image, detections, tags, source, creation_date))
+            background_tasks.create(self.outbox.save(raw_image, metadata))
         elif autoupload == 'disabled':
             pass
         else:
             self.log.error('unknown autoupload value %s', autoupload)
-        return detections
+        return metadata
 
     async def get_batch_detections(self,
                                    raw_images: List[bytes],
@@ -541,7 +549,7 @@ class DetectorNode(Node):
                                    *,
                                    camera_id: Optional[str] = None,
                                    source: Optional[str] = None,
-                                   autoupload: Optional[str] = None,
+                                   autoupload: str = 'filtered',
                                    creation_date: Optional[str] = None) -> ImagesMetadata:
         """ Processing function for the detector node when a a batch inference is requested via SocketIO.
         This function infers the detections from all images, cares about uploading to the loop and returns the detections as a list of ImageMetadata."""
@@ -556,13 +564,10 @@ class DetectorNode(Node):
             n_po, n_se = len(detections.point_detections), len(detections.segmentation_detections)
             self.log.debug('Detected: %d boxes, %d points, %d segs, %d classes', n_bo, n_po, n_se, n_cl)
 
-            autoupload = autoupload or 'filtered'
-            if autoupload == 'filtered' and camera_id is not None:
-                background_tasks.create(self.relevance_filter.may_upload_detections(
-                    detections, camera_id, raw_image, tags, source, creation_date
-                ))
+            if autoupload == 'filtered':
+                background_tasks.create(self.relevance_filter.may_upload_detections(detections, camera_id, raw_image))
             elif autoupload == 'all':
-                background_tasks.create(self.outbox.save(raw_image, detections, tags, source, creation_date))
+                background_tasks.create(self.outbox.save(raw_image, detections))
             elif autoupload == 'disabled':
                 pass
             else:
@@ -572,24 +577,25 @@ class DetectorNode(Node):
     async def upload_images(
             self, *,
             images: List[bytes],
-            image_metadata: Optional[ImageMetadata] = None,
-            tags: Optional[List[str]] = None,
-            source: Optional[str],
-            creation_date: Optional[str],
+            images_metadata: Optional[ImagesMetadata] = None,
             upload_priority: bool = False
     ) -> None:
         """Save images to the outbox using an asyncio executor.
-        Used by SIO and REST upload endpoints."""
+        Used by SIO and REST upload endpoints.
 
-        if image_metadata is None:
-            image_metadata = ImageMetadata()
-        if tags is None:
-            tags = []
+        :param images: List of images to upload
+        :param images_metadata: Optional metadata for all images
+        :param upload_priority: Whether to upload the images with priority
+        :raises ValueError: If the number of images and number of metadata items do not match
+        """
 
-        tags.append('picked_by_system')
+        if images_metadata and len(images_metadata.items) != len(images):
+            raise ValueError('Number of images and number of metadata items do not match')
 
-        for image in images:
-            await self.outbox.save(image, image_metadata, tags, source, creation_date, upload_priority)
+        for i, image in enumerate(images):
+            image_metadata = images_metadata.items[i] if images_metadata else ImageMetadata()
+            image_metadata.tags.append('picked_by_system')
+            await self.outbox.save(image, image_metadata, upload_priority)
 
     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):
@@ -628,9 +634,9 @@ def step_into(new_dir):
         os.chdir(previous_dir)
 
 
-def fix_shape_detections(detections: ImageMetadata):
+def fix_shape_detections(metadata: ImageMetadata):
     # TODO This is a quick fix.. check how loop upload detections deals with this
-    for seg_detection in detections.segmentation_detections:
+    for seg_detection in metadata.segmentation_detections:
         if isinstance(seg_detection.shape, Shape):
             points = ','.join([str(value) for p in seg_detection.shape.points for _,
                                value in asdict(p).items()])

learning_loop_node/detector/inbox_filter/relevance_filter.py

@@ -9,28 +9,30 @@ class RelevanceFilter():
 
     def __init__(self, outbox: Outbox) -> None:
         self.cam_histories: Dict[str, CamObservationHistory] = {}
+        self.unknown_cam_history: CamObservationHistory = CamObservationHistory()
         self.outbox: Outbox = outbox
 
     async def may_upload_detections(self,
                                     image_metadata: ImageMetadata,
-                                    cam_id: str,
-                                    raw_image: bytes,
-                                    tags: List[str],
-                                    source: Optional[str] = None,
-                                    creation_date: Optional[str] = None) -> List[str]:
+                                    cam_id: Optional[str],
+                                    raw_image: bytes) -> List[str]:
         """Check if the detection should be uploaded to the outbox.
         If so, upload it and return the list of causes for the upload.
         """
         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(image_metadata)
+        if cam_id is None:
+            history = self.unknown_cam_history
+        else:
+            if cam_id not in self.cam_histories:
+                self.cam_histories[cam_id] = CamObservationHistory()
+            history = self.cam_histories[cam_id]
+
+        causes = history.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)
-            await self.outbox.save(raw_image, image_metadata, tags, source, creation_date)
+            image_metadata.tags.extend(causes)
+            await self.outbox.save(raw_image, image_metadata)
         return causes

learning_loop_node/detector/outbox.py

@@ -78,9 +78,6 @@ class Outbox():
     async def save(self,
                    image: bytes,
                    image_metadata: Optional[ImageMetadata] = None,
-                   tags: Optional[List[str]] = None,
-                   source: Optional[str] = None,
-                   creation_date: Optional[str] = None,
                    upload_priority: bool = False) -> None:
 
         if not await run.io_bound(self._is_valid_jpg, image):
@@ -89,12 +86,11 @@ class Outbox():
 
         if image_metadata is None:
             image_metadata = ImageMetadata()
-        if not tags:
-            tags = []
+
         identifier = datetime.now().isoformat(sep='_', timespec='microseconds')
 
         try:
-            await run.io_bound(self._save_files_to_disk, identifier, image, image_metadata, tags, source, creation_date, upload_priority)
+            await run.io_bound(self._save_files_to_disk, identifier, image, image_metadata, upload_priority)
         except Exception as e:
             self.log.error('Failed to save files for image %s: %s', identifier, e)
             return
@@ -110,9 +106,6 @@ class Outbox():
                             identifier: str,
                             image: bytes,
                             image_metadata: ImageMetadata,
-                            tags: List[str],
-                            source: Optional[str],
-                            creation_date: Optional[str],
                             upload_priority: bool) -> None:
         subpath = 'priority' if upload_priority else 'normal'
         full_path = f'{self.path}/{subpath}/{identifier}'
@@ -120,14 +113,6 @@ class Outbox():
             raise FileExistsError(f'Directory with identifier {identifier} already exists')
 
         tmp = f'{GLOBALS.data_folder}/tmp/{identifier}'
-        image_metadata.tags = tags
-        if self._is_valid_isoformat(creation_date):
-            image_metadata.created = creation_date
-        else:
-            image_metadata.created = identifier
-
-        image_metadata.source = source or 'unknown'
-
         os.makedirs(tmp, exist_ok=True)
 
         with open(tmp + f'/image_{identifier}.json', 'w') as f:
@@ -139,6 +124,7 @@ class Outbox():
         if not os.path.exists(tmp):
             self.log.error('Could not rename %s to %s', tmp, full_path)
             raise FileNotFoundError(f'Could not rename {tmp} to {full_path}')
+
         os.rename(tmp, full_path)
 
     async def _trim_upload_queue(self) -> None:

learning_loop_node/detector/rest/detect.py

@@ -1,6 +1,11 @@
 import logging
 from typing import TYPE_CHECKING, Optional
 
+try:
+    from typing import Literal
+except ImportError:  # Python <= 3.8
+    from typing_extensions import Literal  # type: ignore
+
 from fastapi import APIRouter, File, Header, Request, UploadFile
 
 from ...data_classes.image_metadata import ImageMetadata
@@ -16,17 +21,16 @@ async def http_detect(
     request: Request,
     file: UploadFile = File(..., description='The image file to run detection on'),
     camera_id: Optional[str] = Header(None, description='The camera id (used by learning loop)'),
-    mac: Optional[str] = Header(None, description='The camera mac address (used by learning loop)'),
     tags: Optional[str] = Header(None, description='Tags to add to the image (used by learning loop)'),
     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']),
+    autoupload: Optional[Literal['filtered', 'all', 'disabled']] = 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:
 
-        curl --request POST -F 'file=@test.jpg' localhost:8004/detect -H 'autoupload: all' -H 'camera-id: front_cam' -H 'source: test' -H 'tags: test,test2'
+        curl --request POST -F 'file=@test.jpg' localhost:8004/detect -H 'autoupload: all' -H 'camera_id: front_cam' -H 'source: test' -H 'tags: test,test2'
 
     Multiple images example:
 
@@ -43,10 +47,10 @@ async def http_detect(
     try:
         app: 'DetectorNode' = request.app
         detections = await app.get_detections(raw_image=file_bytes,
-                                              camera_id=camera_id or mac or None,
+                                              camera_id=camera_id or None,
                                               tags=tags.split(',') if tags else [],
                                               source=source,
-                                              autoupload=autoupload,
+                                              autoupload=autoupload or 'filtered',
                                               creation_date=creation_date)
     except Exception as exc:
         logging.exception('Error during detection of image %s.', file.filename)

learning_loop_node/detector/rest/upload.py

@@ -2,6 +2,8 @@ from typing import TYPE_CHECKING, List, Optional
 
 from fastapi import APIRouter, File, Query, Request, UploadFile
 
+from ...data_classes.image_metadata import ImageMetadata, ImagesMetadata
+
 if TYPE_CHECKING:
     from ..detector_node import DetectorNode
 
@@ -25,6 +27,14 @@ async def upload_image(request: Request,
         curl -X POST -F 'files=@test.jpg' "http://localhost:/upload?source=test&creation_date=2024-01-01T00:00:00&upload_priority=true"
     """
     raw_files = [await file.read() for file in files]
+    image_metadatas = []
+    for _ in files:
+        image_metadatas.append(ImageMetadata(source=source, created=creation_date))
+
+    images_metadata = ImagesMetadata(items=image_metadatas)
+
     node: DetectorNode = request.app
-    await node.upload_images(images=raw_files, source=source, creation_date=creation_date, upload_priority=upload_priority)
+    await node.upload_images(images=raw_files,
+                             images_metadata=images_metadata,
+                             upload_priority=upload_priority)
     return 200, "OK"

learning_loop_node/helpers/background_tasks.py

@@ -21,7 +21,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-"""inspired from https://quantlane.com/blog/ensure-asyncio-task-exceptions-get-logged/"""
 from __future__ import annotations
 
 import asyncio

learning_loop_node/tests/detector/conftest.py

@@ -135,10 +135,9 @@ class MockDetectorLogic(DetectorLogic):  # pylint: disable=abstract-method
                                          category_id="1",
                                          confidence=0.9,
                                          x=0, y=0, width=10, height=10,
-                                         model_name="mock",
-                                         )])
+                                         model_name="mock", )])
 
-    def evaluate_with_all_info(self, image: np.ndarray, tags: List[str], source: Optional[str] = None, creation_date: Optional[str] = None):
+    def evaluate(self, image: bytes) -> ImageMetadata:
         return self.image_metadata
 
 

learning_loop_node/tests/detector/inbox_filter/test_unexpected_observations_count.py

@@ -16,7 +16,7 @@ l_conf_point_det = PointDetection(category_name='point', x=100, y=100,
 
 
 @pytest.mark.parametrize(
-    "detections,reason",
+    "metadata,reason",
     [(ImageMetadata(box_detections=[h_conf_box_det] * 40, point_detections=[h_conf_point_det] * 40),
       ['unexpected_observations_count']),
      (ImageMetadata(box_detections=[h_conf_box_det], point_detections=[h_conf_point_det]), []),
@@ -25,10 +25,10 @@ l_conf_point_det = PointDetection(category_name='point', x=100, y=100,
      (ImageMetadata(box_detections=[h_conf_box_det], point_detections=[l_conf_point_det]),
       ['uncertain'])])
 @pytest.mark.asyncio
-async def test_unexpected_observations_count(detections: ImageMetadata, reason: List[str]):
+async def test_unexpected_observations_count(metadata: ImageMetadata, reason: List[str]):
     os.environ['LOOP_ORGANIZATION'] = 'zauberzeug'
     os.environ['LOOP_PROJECT'] = 'demo'
     outbox = Outbox()
 
     relevance_filter = RelevanceFilter(outbox)
-    assert await relevance_filter.may_upload_detections(detections, raw_image=b'', cam_id='0:0:0:0', tags=[]) == reason
+    assert await relevance_filter.may_upload_detections(metadata, raw_image=b'', cam_id='0:0:0:0') == reason

learning_loop_node/tests/detector/test_detector_node.py

@@ -1,13 +1,16 @@
+from typing import List, Literal, Tuple
+
 import numpy as np
 import pytest
 
+from learning_loop_node.detector import detector_node as detector_node_module
 from learning_loop_node.detector.detector_node import DetectorNode
 
 
 @pytest.mark.asyncio
 async def test_get_detections(detector_node: DetectorNode, monkeypatch):
     # Mock raw image data
-    raw_image = np.zeros((100, 100, 3), dtype=np.uint8)
+    raw_image = np.zeros((100, 100, 3), dtype=np.uint8).tobytes()
 
     # Mock relevance_filter and outbox
     filtered_upload_called = False
@@ -15,11 +18,12 @@ async def test_get_detections(detector_node: DetectorNode, monkeypatch):
 
     save_args = []
 
-    def mock_filtered_upload(*args, **kwargs):  # pylint: disable=unused-argument
+    async def mock_filtered_upload(*args, **kwargs) -> List[str]:  # pylint: disable=unused-argument
         nonlocal filtered_upload_called
         filtered_upload_called = True
+        return []
 
-    def mock_save(*args, **kwargs):
+    async def mock_save(*args, **kwargs):
         nonlocal save_called
         nonlocal save_args
         save_called = True
@@ -28,9 +32,14 @@ async def test_get_detections(detector_node: DetectorNode, monkeypatch):
     monkeypatch.setattr(detector_node.relevance_filter, "may_upload_detections", mock_filtered_upload)
     monkeypatch.setattr(detector_node.outbox, "save", mock_save)
 
+    created_tasks = []
+
+    def mock_create_task(coroutine, *args, **kwargs):
+        created_tasks.append(coroutine)
+    monkeypatch.setattr(detector_node_module.background_tasks, "create", mock_create_task)
+
     # Test cases
-    test_cases = [
-        (None, True, False),
+    test_cases: List[Tuple[Literal['filtered', 'all', 'disabled'], bool, bool]] = [
         ("filtered", True, False),
         ("all", False, True),
         ("disabled", False, False),
@@ -39,14 +48,12 @@ async def test_get_detections(detector_node: DetectorNode, monkeypatch):
     expected_save_args = {
         'image': raw_image,
         'detections': detector_node.detector_logic.image_metadata,  # type: ignore
-        'tags': ['test_tag'],
-        'source': 'test_source',
-        'creation_date': '2024-01-01T00:00:00',
     }
 
     for autoupload, expect_filtered, expect_all in test_cases:
         filtered_upload_called = False
         save_called = False
+        created_tasks.clear()
 
         result = await detector_node.get_detections(
             raw_image=raw_image,
@@ -57,6 +64,9 @@ async def test_get_detections(detector_node: DetectorNode, monkeypatch):
             autoupload=autoupload
         )
 
+        for task in created_tasks:
+            await task
+
         # Check if detections were processed
         assert result is not None
         assert result.box_detections is not None

learning_loop_node/tests/detector/test_relevance_filter.py

@@ -13,7 +13,7 @@ file_path = os.path.abspath(__file__)
 test_image_path = os.path.join(os.path.dirname(file_path), 'test.jpg')
 
 
-@pytest.mark.parametrize('autoupload, expected_file_count', [(None, 2), ('all', 4)])
+@pytest.mark.parametrize('autoupload, expected_file_count', [('filtered', 2), ('all', 4)])
 async def test_filter_is_used_by_node(test_detector_node: DetectorNode, autoupload, expected_file_count):
     """Test if filtering is used by the node. In particular, when upload is filtered, the identical detections should not be uploaded twice.
     Note thatt we have to mock the dummy detections to only return a point and a box detection."""

learning_loop_node/tests/detector/testing_detector.py

@@ -1,10 +1,11 @@
 import logging
+from typing import List
 
-import numpy as np
+from learning_loop_node.data_classes import ImagesMetadata
 
 from ...data_classes import ImageMetadata
 from ...detector.detector_logic import DetectorLogic
-from ..test_helper import get_dummy_detections
+from ..test_helper import get_dummy_metadata
 
 
 class TestingDetectorLogic(DetectorLogic):
@@ -12,11 +13,14 @@ class TestingDetectorLogic(DetectorLogic):
 
     def __init__(self) -> None:
         super().__init__('mocked')
-        self.det_to_return: ImageMetadata = get_dummy_detections()
+        self.det_to_return: ImageMetadata = get_dummy_metadata()
 
     def init(self) -> None:
         pass
 
-    def evaluate(self, image: np.ndarray) -> ImageMetadata:
+    def evaluate(self, image: bytes) -> ImageMetadata:
         logging.info('evaluating')
         return self.det_to_return
+
+    def batch_evaluate(self, images: List[bytes]) -> ImagesMetadata:
+        raise NotImplementedError()

learning_loop_node/tests/test_helper.py

@@ -6,8 +6,16 @@ import zipfile
 from glob import glob
 from typing import Callable
 
-from ..data_classes import (BoxDetection, ClassificationDetection, Detections, Point, PointDetection,
-                            SegmentationDetection, Shape)
+from ..data_classes import (
+    BoxDetection,
+    ClassificationDetection,
+    Detections,
+    Point,
+    PointDetection,
+    SegmentationDetection,
+    Shape,
+)
+from ..data_classes.image_metadata import ImageMetadata
 from ..loop_communication import LoopCommunicator
 
 
@@ -62,7 +70,7 @@ def _update_attribute_dict(obj: dict, **kwargs) -> None:
         obj[key] = value
 
 
-def get_dummy_detections():
+def get_dummy_detections() -> Detections:
     return Detections(
         box_detections=[
             BoxDetection(category_name='some_category_name', x=1, y=2, height=3, width=4,
@@ -78,3 +86,11 @@ def get_dummy_detections():
         classification_detections=[
             ClassificationDetection(category_name='some_category_name_4', model_name='some_model',
                                     confidence=.42, category_id='some_id_4')])
+
+
+def get_dummy_metadata() -> ImageMetadata:
+    detections = get_dummy_detections()
+    return ImageMetadata(box_detections=detections.box_detections,
+                         point_detections=detections.point_detections,
+                         segmentation_detections=detections.segmentation_detections,
+                         classification_detections=detections.classification_detections)

learning_loop_node/tests/trainer/states/test_state_detecting.py

@@ -16,7 +16,8 @@ def trainer_has_detecting_error(trainer: TrainerLogic):
 async def test_successful_detecting(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
     create_active_training_file(trainer, training_state='train_model_uploaded',
-                                model_uuid_for_detecting='00000000-0000-0000-0000-000000000011')  # NOTE: this is the hard coded model uuid for zauberzeug/demo (model version 1.1)
+                                # NOTE: this is the hard coded model uuid for zauberzeug/demo (model version 1.1)
+                                model_uuid_for_detecting='00000000-0000-0000-0000-000000000011')
 
     _ = asyncio.get_running_loop().create_task(
         trainer._perform_state('detecting', TrainerState.Detecting, TrainerState.Detected, trainer._do_detections))

{learning_loop_node-0.16.1.dist-info → learning_loop_node-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learning-loop-node
-Version: 0.16.1
+Version: 0.17.0
 Summary: Python Library for Nodes which connect to the Zauberzeug Learning Loop
 Home-page: https://github.com/zauberzeug/learning_loop_node
 License: MIT
@@ -85,34 +85,48 @@ from learning_loop_node/learning_loop_node
 
 Detector Nodes are normally deployed on edge devices like robots or machinery but can also run in the cloud to provide backend services for an app or similar. These nodes register themself at the Learning Loop. They provide REST and Socket.io APIs to run inference on images. The processed images can automatically be used for active learning: e.g. uncertain predictions will be send to the Learning Loop.
 
-### Running Inference
+### Inference API
 
 Images can be send to the detector node via socketio or rest.
-The later approach can be used via curl,
+Via **REST** you may provide the following parameters:
+
+- `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled`
+- `camera_id`: a camera identifier (string) used to improve the autoupload filtering
+- `tags`: comma separated list of tags to add to the image in the learning loop
+- `source`: optional source identifier (str) for the image (e.g. a robot id)
+- `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled`
+- `creation_date`: optional creation date (str) for the image in isoformat (e.g. `2023-01-30T12:34:56`)
 
 Example usage:
 
-`curl --request POST -F 'file=@test.jpg' localhost:8004/detect`
+`curl --request POST -F 'file=@test.jpg' -H 'autoupload: all' -H 'camera_id: front_cam' localhost:8004/detect`
+
+To use the **SocketIO** inference EPs, the caller needs to connect to the detector node's SocketIO server and emit the `detect` or `batch_detect` event with the image data and image metadata.
+Example code can be found [in the rosys implementation](https://github.com/zauberzeug/rosys/blob/main/rosys/vision/detector_hardware.py).
+
+### Upload API
 
-Where 8804 is the specified port in this example.
-You can additionally provide the following camera parameters:
+The detector has a **REST** endpoint to upload images (and detections) to the Learning Loop. The endpoint takes a POST request with one or multiple images. The images are expected to be in jpg format. The following optional parameters may be set via headers:
 
-- `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled` (example curl parameter `-H 'autoupload: all'`)
-- `camera-id`: a string which groups images for submission together (example curl parameter `-H 'camera-id: front_cam'`)
+- `source`: optional source identifier (str) for the image (e.g. a robot id)
+- `creation_date`: optional creation date (str) for the image in isoformat (e.g. `2023-01-30T12:34:56`)
+- `upload_priority`: A boolean flag to prioritize the upload (defaults to False)
 
-To use the socketio interface, the caller needs to connect to the detector node's socketio server and emit the `detect` or `batch_detect` event with the image data and image metadata. Example code can be found [in the rosys implementation](https://github.com/zauberzeug/rosys/blob/main/rosys/vision/detector_hardware.py).
+Example:
 
-The detector also has a sio **upload endpoint** that can be used to upload images and detections to the learning loop. The function receives a json dictionary, with the following entries:
+`curl -X POST -F 'files=@test.jpg' "http://localhost:/upload"`
+
+The detector also has a **SocketIO** upload endpoint that can be used to upload images and detections to the learning loop. The function receives a json dictionary, with the following entries:
 
 - `image`: the image data in jpg format
-- `tags`: a list of strings. If not provided the tag is `picked_by_system`
-- `detections`: a dictionary representing the detections. UUIDs for the classes are automatically determined based on the category names. This field is optional. If not provided, no detections are uploaded.
-- `source`: optional source identifier for the image
-- `creation_date`: optional creation date for the image
+
+- `metadata`: a dictionary representing the image metadata. If metadata contains detections and/or annotations, UUIDs for the classes are automatically determined based on the category names. Metadata should follow the schema of the `ImageMetadata` data class.
 - `upload_priority`: boolean flag to prioritize the upload (defaults to False)
 
 The endpoint returns None if the upload was successful and an error message otherwise.
 
+For both ways to upload an image, the tag `picked_by_system` is automatically added to the image metadata.
+
 ### Changing the model versioning mode
 
 The detector can be configured to one of the following behaviors:
@@ -164,12 +178,6 @@ The outbox mode can also be queried via:
 - HTTP: `curl http://localhost/outbox_mode`
 - SocketIO: `sio.emit('get_outbox_mode')`
 
-### Explicit upload
-
-The detector has a REST endpoint to upload images (and detections) to the Learning Loop. The endpoint takes a POST request with the image and optionally the detections. The image is expected to be in jpg format. The detections are expected to be a json dictionary. Example:
-
-`curl -X POST -F 'files=@test.jpg' "http://localhost:/upload"`
-
 ## Trainer Node
 
 Trainers fetch the images and anntoations from the Learning Loop to train new models.
@@ -184,7 +192,7 @@ A Conveter Node converts models from one format into another.
 
 ...
 
-#### Test operability
+### Test operability
 
 Assumend there is a Converter Node which converts models of format 'format_a' into 'format_b'.
 Upload a model with

{learning_loop_node-0.16.1.dist-info → learning_loop_node-0.17.0.dist-info}/RECORD

@@ -2,30 +2,31 @@ learning_loop_node/__init__.py,sha256=onN5s8-x_xBsCM6NLmJO0Ym1sJHeCFaGw8qb0oQZmz
 learning_loop_node/annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/annotation/annotator_logic.py,sha256=BTaopkJZkIf1CI5lfsVKsxbxoUIbDJrevavuQUT5e_c,1000
 learning_loop_node/annotation/annotator_node.py,sha256=J5xwSnM5rwTWrTe-TI37J0JHKf_4PlDuABaHvgjYr_Q,4443
-learning_loop_node/data_classes/__init__.py,sha256=6-pLbokCAvTFW-lh1lLUu7u8V5ZyD-2IVmFg5HHI4Cc,1329
-learning_loop_node/data_classes/annotations.py,sha256=NfMlTv2_5AfVY_JDM4tbjETFjSN2S2I2LJJPMMcDT50,966
-learning_loop_node/data_classes/detections.py,sha256=7vqcS0EK8cmDjRDckHlpSZDZ9YO6qajRmYvx-oxatFc,5425
+learning_loop_node/data_classes/__init__.py,sha256=_2dxfVkkI9kNM955Y7ZE8RLgfpegZpX5tXkkPP_n6Fo,1354
+learning_loop_node/data_classes/annotation_data.py,sha256=NfMlTv2_5AfVY_JDM4tbjETFjSN2S2I2LJJPMMcDT50,966
+learning_loop_node/data_classes/annotations.py,sha256=ha7uuWmZqW-LU2vYrkvfnaVpvf5C2xdm826IVVBu0w0,1848
+learning_loop_node/data_classes/detections.py,sha256=hGSKc1elk4Drp4XUjQ3F9HGeRpyLvA0q064b-S9lIug,5335
 learning_loop_node/data_classes/general.py,sha256=GQ6vPEIm4qqBV4RZT_YS_dPeKMdbCKo6Pe5-e4Cg3_k,7295
-learning_loop_node/data_classes/image_metadata.py,sha256=YccDyHMbnOrRr4-9hHbCNBpuhlZem5M64c0ZbZXTASY,1764
+learning_loop_node/data_classes/image_metadata.py,sha256=4FFs89iZAfr2Jh-40QqZ_GGmJ8hl_W61eHcCqHflJLE,2293
 learning_loop_node/data_classes/socket_response.py,sha256=tIdt-oYf6ULoJIDYQCecNM9OtWR6_wJ9tL0Ksu83Vko,655
 learning_loop_node/data_classes/training.py,sha256=TybwcCDf_NUaDUaOj30lPm-7Z3Qk9XFRibEX5qIv96Y,5737
 learning_loop_node/data_exchanger.py,sha256=nd9JNPLn9amIeTcSIyUPpbE97ORAcb5yNphvmpgWSUQ,9095
 learning_loop_node/detector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_loop_node/detector/detector_logic.py,sha256=YmsEsqSr0CUUWKtSR7EFU92HA90NvdYiPZGDQKXJUxU,2462
-learning_loop_node/detector/detector_node.py,sha256=IW9vGbl8Xq7DdylYM-jSJtitkCTs4uGYRZyWGuWauYo,29498
+learning_loop_node/detector/detector_logic.py,sha256=0RilHkb_IYFk-BXso1QJ8in01WodbN7XeAXsKzptovY,2470
+learning_loop_node/detector/detector_node.py,sha256=GosNSGsa0wA172xiYk94RT8mMicDI75J8xsZuidYNWg,29716
 learning_loop_node/detector/exceptions.py,sha256=C6KbNPlSbtfgDrZx2Hbhm7Suk9jVoR3fMRCO0CkrMsQ,196
 learning_loop_node/detector/inbox_filter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/detector/inbox_filter/cam_observation_history.py,sha256=1PHgXRrhSQ34HSFw7mdX8ndRxHf_i1aP5nXXnrZxhAY,3312
-learning_loop_node/detector/inbox_filter/relevance_filter.py,sha256=rI46jL9ZuI0hiDVxWCfXllB8DlQyyewNs6oZ6MnglMc,1540
-learning_loop_node/detector/outbox.py,sha256=izWJtnHG0PNX3-YWtkybLch2slnmT2pmAYrqZpHOaTA,12768
+learning_loop_node/detector/inbox_filter/relevance_filter.py,sha256=IpoJMBPAO5GSr2uGINNu5uFar_jxWQWbH0Lz6FQ3n1M,1501
+learning_loop_node/detector/outbox.py,sha256=HaNps_XEbvOZ-jlpZTCsk4Dbk5zq-vNYdKMBu001ckU,12132
 learning_loop_node/detector/rest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/detector/rest/about.py,sha256=evHJ2svUZY_DFz0FSef5u9c5KW4Uc3GL7EbPinG9-dg,583
 learning_loop_node/detector/rest/backdoor_controls.py,sha256=ZNaFOvC0OLWNtcLiG-NIqS_y1kkLP4csgk3CHhp8Gis,885
-learning_loop_node/detector/rest/detect.py,sha256=wYf9cCgtImMgnHbrcE6GMXE2aBopdZciKvGmc92ZCGw,2533
+learning_loop_node/detector/rest/detect.py,sha256=_wPgmlH-vdnprM3fc4s9YlAb0jkSxqG9AVcjMkMhP9I,2641
 learning_loop_node/detector/rest/model_version_control.py,sha256=P4FOG0U9HT6QtCoNt-1s1pT6drtgdVjGZWEuCAyuNmA,1370
 learning_loop_node/detector/rest/operation_mode.py,sha256=1_xfutA_6nzdb4Q_jZiHQ5m_wA83bcG5jSIy-sfNIvk,1575
 learning_loop_node/detector/rest/outbox_mode.py,sha256=H8coDNbgLGEfXmKQrhtXWeUHBAHpnrdZktuHXQz0xis,1148
-learning_loop_node/detector/rest/upload.py,sha256=GMDKyN3UNfzsKq5GtBBlv828lht0bztgqRqT_PQHkZM,1250
+learning_loop_node/detector/rest/upload.py,sha256=YrIa1kILvShOn-S7Bm74zRDod-oA-Q9NLQXw6BSgB0U,1562
 learning_loop_node/enums/__init__.py,sha256=tjSrhztIQ8W656_QuXfTbbVNtH_wDXP5hpYZgzfgRhc,285
 learning_loop_node/enums/annotator.py,sha256=mtTAw-8LJIrHcYkBjYHCZuhYEEHS6QzSK8k6BhLusvQ,285
 learning_loop_node/enums/detector.py,sha256=Qvm5LWWR9BfsDxHEQ8YzaPaUuSmp4BescYuV4X4ikwE,512
@@ -34,7 +35,7 @@ learning_loop_node/enums/trainer.py,sha256=VaD63guLO4aKgVfXT0EryPlXKQGegSET3Cp4R
 learning_loop_node/examples/novelty_score_updater.py,sha256=1DRgM9lxjFV-q2JvGDDsNLz_ic_rhEZ9wc6ZdjcxwPE,2038
 learning_loop_node/globals.py,sha256=tgw_8RYOipPV9aYlyUhYtXfUxvJKRvfUk6u-qVAtZmY,174
 learning_loop_node/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_loop_node/helpers/background_tasks.py,sha256=sNKyHyk9J5vNn-0GG1OzNJbB-F7GXGcbCWKE3MbRrno,3346
+learning_loop_node/helpers/background_tasks.py,sha256=gAaEXurrW_pkYlDYD-NhWvFZpU7kwoo-SzTFCckURlo,3256
 learning_loop_node/helpers/environment_reader.py,sha256=6DxDJecLHxiGczByhyVa_JssAwwft7vuNCGaEzoSY2I,1662
 learning_loop_node/helpers/gdrive_downloader.py,sha256=zeYJciTAJVRpu_eFjwgYLCpIa6hU1d71anqEBb564Rk,1145
 learning_loop_node/helpers/log_conf.py,sha256=hqVAa_9NnYEU6N0dcOKmph82p7MpgKqeF_eomTLYzWY,961
@@ -50,18 +51,18 @@ learning_loop_node/tests/annotator/conftest.py,sha256=e83I8WNAUgCFmum1GCx_nSjP9u
 learning_loop_node/tests/annotator/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0W5UOnDfGGs_igU,262
 learning_loop_node/tests/annotator/test_annotator_node.py,sha256=OgdUj0PEWSe0KPTNVVi-1d7DoK7IC9Q3Q3G8TPiP9f4,2090
 learning_loop_node/tests/detector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_loop_node/tests/detector/conftest.py,sha256=Z1uPZGSL5jZyRQkHycQpHjsBjn-sL1QfuJrrJrGTNtM,5517
+learning_loop_node/tests/detector/conftest.py,sha256=c0L8KRpuV4No9YUOXo5eWvsjyCZhrI2CvDDlTMwKlrI,5390
 learning_loop_node/tests/detector/inbox_filter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/detector/inbox_filter/test_observation.py,sha256=k4WYdvnuV7d_r7zI4M2aA8WuBjm0aycQ0vj1rGE2q4w,1370
 learning_loop_node/tests/detector/inbox_filter/test_relevance_group.py,sha256=r-wABFQVsTNTjv7vYGr8wbHfOWy43F_B14ZDWHfiZ-A,7613
-learning_loop_node/tests/detector/inbox_filter/test_unexpected_observations_count.py,sha256=JbUnPZVjzdtAlp6cTZVAdXUluQYNueGU9eITNJKY-tU,1710
+learning_loop_node/tests/detector/inbox_filter/test_unexpected_observations_count.py,sha256=KoK7lL9u0N6CeZcOCCNBGDmNnXzcmMSqYM16s-A7VO4,1695
 learning_loop_node/tests/detector/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0W5UOnDfGGs_igU,262
 learning_loop_node/tests/detector/test.jpg,sha256=msA-vHPmvPiro_D102Qmn1fn4vNfooqYYEXPxZUmYpk,161390
 learning_loop_node/tests/detector/test_client_communication.py,sha256=cVviUmAwbLY3LsJcY-D3ve-Jwxk9WVOrVupeh-PdKtA,8013
-learning_loop_node/tests/detector/test_detector_node.py,sha256=0ZMV6coAvdq-nH8CwY9_LR2tUcH9VLcAB1CWuwHQMpo,3023
+learning_loop_node/tests/detector/test_detector_node.py,sha256=vw-QOSUav460spujfVoYC7qZwWA5bLpbTTGX31rYY9I,3419
 learning_loop_node/tests/detector/test_outbox.py,sha256=K7c0GeKujNlgjDFS3aY1lN7kDbfJ4dBQfB9lBp3o3_Q,3262
-learning_loop_node/tests/detector/test_relevance_filter.py,sha256=7oTXW4AuObk7NxMqGSwnjcspH3-QUbSdCYlz9hvzV78,2079
-learning_loop_node/tests/detector/testing_detector.py,sha256=MZajybyzISz2G1OENfLHgZhBcLCYzTR4iN9JkWpq5-s,551
+learning_loop_node/tests/detector/test_relevance_filter.py,sha256=Lki8ElGdjm0yhxY-dy_46DJjOgj7HpTa7SbnBMKjjZ4,2085
+learning_loop_node/tests/detector/testing_detector.py,sha256=UqrFHS0AhrB1bOfvOvU5U_0ukfm5_aYNcGfPc59mGg8,712
 learning_loop_node/tests/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/general/conftest.py,sha256=kEtkuVA2wgny-YBkLDn7Ff5j6ShOPghQUU0cH9IIl_8,2430
 learning_loop_node/tests/general/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0W5UOnDfGGs_igU,262
@@ -71,14 +72,14 @@ learning_loop_node/tests/general/test_data/model.json,sha256=_xNDucGOWila8gWnu8y
 learning_loop_node/tests/general/test_data_classes.py,sha256=RnDzRtB-eRfWnaaA6qAzC1W8wurFzJ4xt1Q5pd7ZCS0,721
 learning_loop_node/tests/general/test_downloader.py,sha256=y4GcUyR0OAfrwltd6eyQgopwTt3DwjzX0Sr8yrooLec,3347
 learning_loop_node/tests/general/test_learning_loop_node.py,sha256=SZd-VChpWnnsPN46pr4E_LL3ZevYx6psU-AWdVeOFpQ,770
-learning_loop_node/tests/test_helper.py,sha256=Xajn6BWJqeD36YAETwdcJd6awY2NPmaOis3gWgFc97k,2909
+learning_loop_node/tests/test_helper.py,sha256=Qj_jS0xVOnwZvSJjUkrDxRXFe93hSi0RdG0wAlDVguo,3379
 learning_loop_node/tests/trainer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/trainer/conftest.py,sha256=eJUUBVRTmwcEooEN29hIa3eNuo0ogAPNn7Vqs9FSRDM,3660
 learning_loop_node/tests/trainer/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0W5UOnDfGGs_igU,262
 learning_loop_node/tests/trainer/state_helper.py,sha256=MDe9opeKruip74FoRFff8MSWGiQNFqDpPtIEIbgPnFc,919
 learning_loop_node/tests/trainer/states/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/trainer/states/test_state_cleanup.py,sha256=gZNxSSwnj9f0esExNnQzqadM6-sE3IsF5sNbD0bZNu8,1250
-learning_loop_node/tests/trainer/states/test_state_detecting.py,sha256=-NLR5se7_OY_X8_Gf-BWw7X6dS_Pzsnkz84J5aTbqFU,3689
+learning_loop_node/tests/trainer/states/test_state_detecting.py,sha256=y3WCOqe4LPH4Rf97x7MmybbHOBwEqS3oOxg0TxScSX8,3720
 learning_loop_node/tests/trainer/states/test_state_download_train_model.py,sha256=-T8iAutBliv0MV5bV5lPvn2aNjF3vMBCj8iAZTC-Q7g,2992
 learning_loop_node/tests/trainer/states/test_state_prepare.py,sha256=boCU93Bv2VWbW73MC_suTbwCcuR7RWn-6dgVvdiJ9tA,2291
 learning_loop_node/tests/trainer/states/test_state_sync_confusion_matrix.py,sha256=R3UqQJ2GQMapwRQ5WuZJb9M5IfroD2QqFI4h8etiH0Y,5223
@@ -99,6 +100,6 @@ learning_loop_node/trainer/test_executor.py,sha256=6BVGDN_6f5GEMMEvDLSG1yzMybSvg
 learning_loop_node/trainer/trainer_logic.py,sha256=eK-01qZzi10UjLMCQX8vy5eW2FoghPj3rzzDC-s3Si4,8792
 learning_loop_node/trainer/trainer_logic_generic.py,sha256=KcHmXr-Hp8_Wuejzj8odY6sRPqi6aw1SEXv3YlbjM98,27057
 learning_loop_node/trainer/trainer_node.py,sha256=tsAMzJewdS7Bi_1b9FwG0d2lGlv2lY37pgOLWr0bP_I,4582
-learning_loop_node-0.16.1.dist-info/METADATA,sha256=nHAEMpBL_tSXA00hNvuLoAuh0RcS1FACaCS_JsCP7rA,13509
-learning_loop_node-0.16.1.dist-info/WHEEL,sha256=WGfLGfLX43Ei_YORXSnT54hxFygu34kMpcQdmgmEwCQ,88
-learning_loop_node-0.16.1.dist-info/RECORD,,
+learning_loop_node-0.17.0.dist-info/METADATA,sha256=7obfPe_Nc6q2j40ns2teaGxoA1tpnmPFFd6XAIoeuvw,13979
+learning_loop_node-0.17.0.dist-info/WHEEL,sha256=WGfLGfLX43Ei_YORXSnT54hxFygu34kMpcQdmgmEwCQ,88
+learning_loop_node-0.17.0.dist-info/RECORD,,