learning-loop-node 0.10.16__py3-none-any.whl → 0.11.0__py3-none-any.whl

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/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/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/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/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/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/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/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
 
@@ -32,7 +32,6 @@ class OutboxMode(Enum):
 class Outbox():
     def __init__(self) -> None:
         self.log = logging.getLogger()
-        self.log.setLevel(logging.DEBUG)
         self.path = f'{GLOBALS.data_folder}/outbox'
         os.makedirs(self.path, exist_ok=True)
 
@@ -57,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')
@@ -75,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)
@@ -91,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/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/detector/rest/upload.py

@@ -1,6 +1,6 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, File, Request, UploadFile
+from fastapi import APIRouter, File, Query, Request, UploadFile
 
 if TYPE_CHECKING:
     from ..detector_node import DetectorNode
@@ -9,13 +9,21 @@ router = APIRouter()
 
 
 @router.post("/upload")
-async def upload_image(request: Request, files: List[UploadFile] = File(...)):
+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"
+        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)
+    await node.upload_images(raw_files, source, creation_date)
     return 200, "OK"

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/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/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()

learning_loop_node/tests/detector/test_client_communication.py

@@ -3,7 +3,7 @@ import json
 import os
 
 import pytest
-import requests
+import requests  # type: ignore
 
 from ...data_classes import ModelInformation
 from ...detector.detector_node import DetectorNode
@@ -93,7 +93,7 @@ async def test_sio_upload(test_detector_node: DetectorNode, sio_client):
 
 # NOTE: This test seems to be flaky.
 async def test_about_endpoint(test_detector_node: DetectorNode):
-    await asyncio.sleep(11)
+    await asyncio.sleep(16)
     response = requests.get(f'http://localhost:{GLOBALS.detector_port}/about', timeout=30)
 
     assert response.status_code == 200, response.content
@@ -108,60 +108,60 @@ async def test_about_endpoint(test_detector_node: DetectorNode):
 
 
 async def test_model_version_api(test_detector_node: DetectorNode):
-    await asyncio.sleep(11)
-
-    response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200, response.content
-    response_dict = json.loads(response.content)
-    assert response_dict['version_control'] == 'follow_loop'
-    assert response_dict['current_version'] == '1.1'
-    assert response_dict['target_version'] == '1.1'
-    assert response_dict['loop_version'] == '1.1'
-    assert response_dict['local_versions'] == ['1.1']
+    async def await_correct_response(target_values: dict) -> None:
+        response_dict = {}
+        for _ in range(20):
+            await asyncio.sleep(1)
+            response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
+            if not response.status_code == 200:
+                continue
+            response_dict = json.loads(response.content)
+            for key, target_value in target_values.items():
+                if key == 'local_versions':
+                    target_value = set(target_value)
+
+                response_value = response_dict.get(key, None)
+                if response_value != target_value:
+                    break
+            return
+        raise Exception(f'Did not receive correct response: {response_dict} != {target_values}')
+
+    await await_correct_response({'version_control': 'follow_loop',
+                                  'current_version': '1.1',
+                                  'target_version': '1.1',
+                                  'loop_version': '1.1',
+                                  'local_versions': ['1.1']})
 
     response = requests.put(f'http://localhost:{GLOBALS.detector_port}/model_version', data='1.0', timeout=30)
     assert response.status_code == 200, response.content
-    response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200, response.content
-    response_dict = json.loads(response.content)
-    assert response_dict['version_control'] == 'specific_version'
-    assert response_dict['current_version'] == '1.1'
-    assert response_dict['target_version'] == '1.0'
-    assert response_dict['loop_version'] == '1.1'
-    assert response_dict['local_versions'] == ['1.1']
 
-    await asyncio.sleep(11)
-    response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200, response.content
-    response_dict = json.loads(response.content)
-    assert response_dict['version_control'] == 'specific_version'
-    assert response_dict['current_version'] == '1.0'
-    assert response_dict['target_version'] == '1.0'
-    assert response_dict['loop_version'] == '1.1'
-    assert set(response_dict['local_versions']) == set(['1.1', '1.0'])
+    await await_correct_response({'version_control': 'specific_version',
+                                  'current_version': '1.1',
+                                  'target_version': '1.0',
+                                  'loop_version': '1.1'})
+
+    await await_correct_response({'version_control': 'specific_version',
+                                  'current_version': '1.0',
+                                  'target_version': '1.0',
+                                  'loop_version': '1.1',
+                                  'local_versions': ['1.1', '1.0']})
 
     response = requests.put(f'http://localhost:{GLOBALS.detector_port}/model_version', data='pause', timeout=30)
     assert response.status_code == 200, response.content
-    await asyncio.sleep(11)
-    response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200, response.content
-    response_dict = json.loads(response.content)
-    assert response_dict['version_control'] == 'pause'
-    assert response_dict['current_version'] == '1.0'
-    assert response_dict['target_version'] == '1.0'
-    assert response_dict['loop_version'] == '1.1'
-    assert set(response_dict['local_versions']) == set(['1.1', '1.0'])
+
+    await await_correct_response({'version_control': 'pause',
+                                  'current_version': '1.0',
+                                  'target_version': '1.0',
+                                  'loop_version': '1.1',
+                                  'local_versions': ['1.1', '1.0']})
 
     response = requests.put(f'http://localhost:{GLOBALS.detector_port}/model_version', data='follow_loop', timeout=30)
     await asyncio.sleep(11)
-    response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200, response.content
-    response_dict = json.loads(response.content)
-    assert response_dict['version_control'] == 'follow_loop'
-    assert response_dict['current_version'] == '1.1'
-    assert response_dict['target_version'] == '1.1'
-    assert response_dict['loop_version'] == '1.1'
-    assert set(response_dict['local_versions']) == set(['1.1', '1.0'])
+    await await_correct_response({'version_control': 'follow_loop',
+                                  'current_version': '1.1',
+                                  'target_version': '1.1',
+                                  'loop_version': '1.1',
+                                  'local_versions': ['1.1', '1.0']})
 
 
 async def test_rest_outbox_mode(test_detector_node: DetectorNode):

learning_loop_node/tests/detector/test_detector_node.py

@@ -38,9 +38,10 @@ async def test_get_detections(detector_node: DetectorNode, monkeypatch):
 
     expected_save_args = {
         'image': raw_image,
-        'detections': detector_node.detector_logic.detections,  # type: ignore
+        '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:
@@ -52,6 +53,7 @@ async def test_get_detections(detector_node: DetectorNode, monkeypatch):
             camera_id="test_camera",
             tags=["test_tag"],
             source="test_source",
+            creation_date="2024-01-01T00:00:00",
             autoupload=autoupload
         )
 

learning_loop_node/tests/detector/test_outbox.py

@@ -6,7 +6,7 @@ import shutil
 import pytest
 from PIL import Image
 
-from ...data_classes import Detections
+from ...data_classes import ImageMetadata
 from ...detector.detector_node import DetectorNode
 from ...detector.outbox import Outbox
 from ...globals import GLOBALS
@@ -28,7 +28,7 @@ async def test_outbox():
 
 @pytest.mark.asyncio
 async def test_files_are_automatically_uploaded_by_node(test_detector_node: DetectorNode):
-    test_detector_node.outbox.save(get_test_image_binary(), Detections())
+    test_detector_node.outbox.save(get_test_image_binary(), ImageMetadata())
     assert await wait_for_outbox_count(test_detector_node.outbox, 1)
     assert await wait_for_outbox_count(test_detector_node.outbox, 0)
 

learning_loop_node/tests/detector/test_relevance_filter.py

@@ -4,7 +4,7 @@ import os
 import numpy as np
 import pytest
 
-from ...data_classes import BoxDetection, Detections, PointDetection
+from ...data_classes import BoxDetection, ImageMetadata, PointDetection
 from ...detector.detector_node import DetectorNode
 from .conftest import get_outbox_files
 from .testing_detector import TestingDetectorLogic
@@ -19,7 +19,7 @@ async def test_filter_is_used_by_node(test_detector_node: DetectorNode, autouplo
     Note thatt we have to mock the dummy detections to only return a point and a box detection."""
 
     assert isinstance(test_detector_node.detector_logic, TestingDetectorLogic)
-    test_detector_node.detector_logic.det_to_return = Detections(
+    test_detector_node.detector_logic.det_to_return = ImageMetadata(
         box_detections=[
             BoxDetection(category_name='some_category_name', x=1, y=2, height=3, width=4,
                          model_name='some_model', confidence=.42, category_id='some_id')],

learning_loop_node/tests/detector/testing_detector.py

@@ -2,7 +2,7 @@ import logging
 
 import numpy as np
 
-from ...data_classes import Detections
+from ...data_classes import ImageMetadata
 from ...detector.detector_logic import DetectorLogic
 from ..test_helper import get_dummy_detections
 
@@ -12,11 +12,11 @@ class TestingDetectorLogic(DetectorLogic):
 
     def __init__(self) -> None:
         super().__init__('mocked')
-        self.det_to_return: Detections = get_dummy_detections()
+        self.det_to_return: ImageMetadata = get_dummy_detections()
 
     def init(self) -> None:
         pass
 
-    def evaluate(self, image: np.ndarray) -> Detections:
+    def evaluate(self, image: np.ndarray) -> ImageMetadata:
         logging.info('evaluating')
         return self.det_to_return

learning_loop_node/tests/general/test_downloader.py

@@ -4,7 +4,7 @@ import shutil
 from ...data_classes import Context
 from ...data_exchanger import DataExchanger
 from ...globals import GLOBALS
-from ...helpers.misc import delete_corrupt_images
+from ...helpers.misc import create_image_folder, create_project_folder, create_training_folder, delete_corrupt_images
 from .. import test_helper
 
 # Used by all Nodes
@@ -77,8 +77,8 @@ async def test_removal_of_corrupted_images(data_exchanger: DataExchanger):
 
 
 def create_needed_folders(training_uuid: str = 'some_uuid'):  # pylint: disable=unused-argument
-    project_folder = test_helper.create_project_folder(
+    project_folder = create_project_folder(
         Context(organization='zauberzeug', project='pytest_nodelib_general'))
-    image_folder = test_helper.create_image_folder(project_folder)
-    training_folder = test_helper.create_training_folder(project_folder, training_uuid)
+    image_folder = create_image_folder(project_folder)
+    training_folder = create_training_folder(project_folder, training_uuid)
     return project_folder, image_folder, training_folder

learning_loop_node/tests/test_helper.py

@@ -6,9 +6,8 @@ import zipfile
 from glob import glob
 from typing import Callable
 
-from ..data_classes import (BoxDetection, ClassificationDetection, Context, Detections, Point, PointDetection,
+from ..data_classes import (BoxDetection, ClassificationDetection, Detections, Point, PointDetection,
                             SegmentationDetection, Shape)
-from ..helpers.misc import create_image_folder, create_project_folder, create_training_folder
 from ..loop_communication import LoopCommunicator
 
 

learning_loop_node/trainer/io_helpers.py

@@ -142,14 +142,14 @@ class ActiveTrainingIO:
 
     async def upload_detetions(self):
         num_files = self.get_number_of_detection_files()
-        print(f'num_files: {num_files}', flush=True)
+        logging.info('Going to upload %s detections', num_files)
         if not num_files:
             logging.error('no detection files found')
             return
         current_json_file_index = self.load_detections_upload_file_index()
         for i in range(current_json_file_index, num_files):
             detections = self.load_detections(i)
-            logging.info(f'uploading detections in file {i}/{num_files}')
+            logging.debug('uploading detections in file %s/%s', i, num_files)
             await self._upload_detections_batched(self.context, detections)
             self.save_detections_upload_file_index(i+1)
 
@@ -166,10 +166,10 @@ class ActiveTrainingIO:
 
     async def _upload_detections_and_save_progress(self, context: Context, batch_detections: List[Detections], up_progress: int):
         if len(batch_detections) == 0:
-            print('skipping empty batch', flush=True)
+            logging.debug('skipping empty batch')
             return
         detections_json = [jsonable_encoder(asdict(detections)) for detections in batch_detections]
-        print(f'uploading {len(detections_json)} detections', flush=True)
+        logging.info('uploading %s detections', len(detections_json))
         response = await self.loop_communicator.post(
             f'/{context.organization}/projects/{context.project}/detections', json=detections_json)
         if response.status_code != 200:

learning_loop_node/trainer/trainer_logic_generic.py

@@ -328,11 +328,11 @@ class TrainerLogicGeneric(ABC):
 
         # TODO this checks if we continue a training -> make more explicit
         if not base_model_uuid or not is_valid_uuid4(base_model_uuid):
-            logger.info(f'skipping model download. No base model provided (in form of uuid): {base_model_uuid}')
+            logger.info('skipping model download. No base model provided (in form of uuid): %s', base_model_uuid)
             return
 
         logger.info('loading model from Learning Loop')
-        logger.info(f'downloading model {base_model_uuid} as {self.model_format}')
+        logger.info('downloading model %s as %s', base_model_uuid, self.model_format)
         await self.node.data_exchanger.download_model(self.training.training_folder, self.training.context, base_model_uuid, self.model_format)
         shutil.move(f'{self.training.training_folder}/model.json',
                     f'{self.training.training_folder}/base_model.json')
@@ -355,7 +355,7 @@ class TrainerLogicGeneric(ABC):
                 result = await self.node.sio_client.call('update_training', (
                     self.training.context.organization, self.training.context.project, jsonable_encoder(new_training)))
                 if isinstance(result,  dict) and result['success']:
-                    logger.info(f'successfully updated training {asdict(new_training)}')
+                    logger.info('successfully updated training %s', asdict(new_training))
                     self._on_metrics_published(new_best_model)
                 else:
                     raise Exception(f'Error for update_training: Response from loop was : {result}')
@@ -369,7 +369,7 @@ class TrainerLogicGeneric(ABC):
         """Uploads the latest model to the Learning Loop.
         """
         new_model_uuid = await self._upload_model_return_new_model_uuid(self.training.context)
-        logger.info(f'Successfully uploaded model and received new model id: {new_model_uuid}')
+        logger.info('Successfully uploaded model and received new model id: %s', new_model_uuid)
         self.training.model_uuid_for_detecting = new_model_uuid
 
     async def _upload_model_return_new_model_uuid(self, context: Context) -> str:
@@ -380,6 +380,7 @@ class TrainerLogicGeneric(ABC):
 
         :return: The new model UUID.
         :raise CriticalError: If the latest model files cannot be obtained.
+        :raise Exception: If the response for the model upload attempt is invalid.
         """
 
         files = await self._get_latest_model_files()
@@ -402,6 +403,9 @@ class TrainerLogicGeneric(ABC):
             already_uploaded_formats.append(file_format)
             self.active_training_io.save_model_upload_progress(already_uploaded_formats)
 
+        if not model_uuid:
+            raise Exception('Invalid response for model upload attempt')
+
         return model_uuid
 
     def _dump_categories_to_json(self) -> str:

{learning_loop_node-0.10.16.dist-info → learning_loop_node-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learning-loop-node
-Version: 0.10.16
+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.16.dist-info → learning_loop_node-0.11.0.dist-info}/RECORD

@@ -2,28 +2,29 @@ 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=UrJ8MpZ44UhsjmVuSHr2BhHyLC-kIMDi3IuBBMKzN1g,4117
-learning_loop_node/data_classes/__init__.py,sha256=wCX88lDgbb8V-gtVCVe9i-NvvZuMe5FX7eD_UJgYYXw,1305
+learning_loop_node/data_classes/__init__.py,sha256=JaEwaBHuDOs0DUkeGT8zLtARD5mvkImY7ZKB9ZuNuRc,1364
 learning_loop_node/data_classes/annotations.py,sha256=iInU0Nuy_oYT_sj4k_n-W0UShCBI2cHQYrt8imymbtM,1211
-learning_loop_node/data_classes/detections.py,sha256=hifsGz2LbmeKLZdHxG7cnlOYNEqDmtJd2gxhyU-Xjjs,5811
+learning_loop_node/data_classes/detections.py,sha256=7vqcS0EK8cmDjRDckHlpSZDZ9YO6qajRmYvx-oxatFc,5425
 learning_loop_node/data_classes/general.py,sha256=usXokcTOVqTuaKJtBf0ffFWfzZhMrQtF7puKfwi6A5k,6195
+learning_loop_node/data_classes/image_metadata.py,sha256=3DZyblzwc_v1SjzBFzqe6nEhL-DQuP75niy5bJCHGbw,1595
 learning_loop_node/data_classes/socket_response.py,sha256=tIdt-oYf6ULoJIDYQCecNM9OtWR6_wJ9tL0Ksu83Vko,655
 learning_loop_node/data_classes/training.py,sha256=hnMHZMk-WNRERyo7U97qL09v1tIdhnzPfTH-JgifLwU,6164
 learning_loop_node/data_exchanger.py,sha256=6wK9hSGjpCxIx3VklEfPoAl3UyEZy5DfKP4sj97kf_w,9116
 learning_loop_node/detector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_loop_node/detector/detector_logic.py,sha256=IG1s9RF_cCBcNQ8WW1rAS37QKdGzlVoVkuO_CrLGvYs,2084
-learning_loop_node/detector/detector_node.py,sha256=TeChzkpVVmEiZbnfWmtkjuUXNwCZvIWfingmcuAz2cs,19567
+learning_loop_node/detector/detector_logic.py,sha256=fAaeLykvkuOeaQx-scuN1pkydK8cPdmNT75P8xqImY0,2130
+learning_loop_node/detector/detector_node.py,sha256=1AJuTONYETLt-vi-nozQBGCnX49eUFaxTCUDzENQu7c,19894
 learning_loop_node/detector/inbox_filter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_loop_node/detector/inbox_filter/cam_observation_history.py,sha256=TD346I9ymtIP0_CJXCIKMRuiXbfVVanXNu_iHAwDd7Q,3318
-learning_loop_node/detector/inbox_filter/relevance_filter.py,sha256=7_-x8D8Zf6KJeJXmiC2VrRHU8Ig_R98uhdXVwwX0N4M,1240
-learning_loop_node/detector/outbox.py,sha256=HrYeS6XJLC-1kqq2hDufxXLRmOYGiBlz-m9B6HG5Ie8,8227
+learning_loop_node/detector/inbox_filter/cam_observation_history.py,sha256=8gzxYPD3t1OS9wBHXfIvNV2xTTMo0B70O1b50iaH2D8,3344
+learning_loop_node/detector/inbox_filter/relevance_filter.py,sha256=NPEmrAtuGjIWCtHS0B3zDmnYWkhVFCLbd_7RUp08_AM,1372
+learning_loop_node/detector/outbox.py,sha256=5YJQhdoo_ryTDOnCaNFMTqUm42Kaw_QkEbTOyZuGcXA,8593
 learning_loop_node/detector/rest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/detector/rest/about.py,sha256=COYgmYO1tXGSIwjF__P79mVZUfSDZoHsW0GUarQ2rv0,1686
 learning_loop_node/detector/rest/backdoor_controls.py,sha256=ZNaFOvC0OLWNtcLiG-NIqS_y1kkLP4csgk3CHhp8Gis,885
-learning_loop_node/detector/rest/detect.py,sha256=KSYUOuTxuc2q3RgV37cBBuCvCJf11BFL7QtnPAM4XbU,2343
+learning_loop_node/detector/rest/detect.py,sha256=ofJ3ysTarbCpiH1YAD6gSJbrDOzAcsLRuGxhr57dtk0,2503
 learning_loop_node/detector/rest/model_version_control.py,sha256=jLp3rvCYq8T_QC3KK7uLDYpbDjydwazWkQCUXvkxl-c,4654
 learning_loop_node/detector/rest/operation_mode.py,sha256=RAzVLtGzy4n9-LSIq_XSwMfXDehU4XmorgWAWbQ6BW8,1804
 learning_loop_node/detector/rest/outbox_mode.py,sha256=H8coDNbgLGEfXmKQrhtXWeUHBAHpnrdZktuHXQz0xis,1148
-learning_loop_node/detector/rest/upload.py,sha256=IPzxJPayD7_Gx5uYC1lVJwWxdnQgM8MYGa5NugXVosY,544
+learning_loop_node/detector/rest/upload.py,sha256=5YWY0Ku4duZqKd6tjyJzq-Ga83o2UYb1VmzuxBIgo0w,1061
 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
@@ -41,18 +42,18 @@ learning_loop_node/tests/annotator/conftest.py,sha256=G4ZvdZUdvPp9bYCzg3eEVkGCeX
 learning_loop_node/tests/annotator/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0W5UOnDfGGs_igU,262
 learning_loop_node/tests/annotator/test_annotator_node.py,sha256=TPNPPrQAxQ_zEecQcH7hlczgD3ABtTCNtUvWD1_oApk,1985
 learning_loop_node/tests/detector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_loop_node/tests/detector/conftest.py,sha256=Q14KHTSuSCsASVIxY9CttdVJm5FC7_JH-W5Q4CdDqoM,5414
+learning_loop_node/tests/detector/conftest.py,sha256=9wMPcj2QvKevyXAU853dGFjcoXdJHOGK8uxxgjSLX3U,5482
 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=XjiMsS0LgvM0OkPf5-s2rjFbG7C42LTmz_rDVMGHKoY,7603
-learning_loop_node/tests/detector/inbox_filter/test_unexpected_observations_count.py,sha256=MWC7PbaCy14jjRw0_oilkXj6gymAsUZXHJdzNW5m2D4,1639
+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=3KKwf-J9oJRMIuuVju2vT9IM9vWhKvswPiXJI8KxmcU,1661
 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=NAOUrHWxoI4yG6oy3BGxWWXX794IOODEj9QBKF3CyrY,9375
-learning_loop_node/tests/detector/test_detector_node.py,sha256=KX2RcFpdIbpPEmcyYM0YMs-6wwTpbOOZONoiwIWryUI,2922
-learning_loop_node/tests/detector/test_outbox.py,sha256=5RMKQfuu1-rvpVCpEtt_D70bYgma-sIrTHWxHdTdU9Y,3001
-learning_loop_node/tests/detector/test_relevance_filter.py,sha256=3VLhHKaxPzLYmiNZagvgg9ZHkPhWk4_-qpmkJw36wBU,2046
-learning_loop_node/tests/detector/testing_detector.py,sha256=FeQroV85IvsT8dmalQBqf1FLNt_buCtZK3-lgtmbrBI,542
+learning_loop_node/tests/detector/test_client_communication.py,sha256=RUsdmZRQE1YO587JPHB2c2-bTE_tmThQodWuhjzBPEk,9180
+learning_loop_node/tests/detector/test_detector_node.py,sha256=0ZMV6coAvdq-nH8CwY9_LR2tUcH9VLcAB1CWuwHQMpo,3023
+learning_loop_node/tests/detector/test_outbox.py,sha256=IfCz4iBmYA4bm3TK4q2NmWyzQCwZWhUbBrKQNHGxZM4,3007
+learning_loop_node/tests/detector/test_relevance_filter.py,sha256=ZKcCstFWCDxJzKdVlAe8E6sZzv5NiH8mADhaZjokHoU,2052
+learning_loop_node/tests/detector/testing_detector.py,sha256=MZajybyzISz2G1OENfLHgZhBcLCYzTR4iN9JkWpq5-s,551
 learning_loop_node/tests/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/general/conftest.py,sha256=oVuE-XZfUPjOXE8KLJgDbIMKIF9Mmgfna2rlupC44TE,2298
 learning_loop_node/tests/general/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0W5UOnDfGGs_igU,262
@@ -60,9 +61,9 @@ learning_loop_node/tests/general/test_data/file_1.txt,sha256=Lis06nfvbFPVCBZyEgQ
 learning_loop_node/tests/general/test_data/file_2.txt,sha256=Xp8EETGhZBdVAgb4URowSSpOytwwwJdV0Renkdur7R8,19
 learning_loop_node/tests/general/test_data/model.json,sha256=_xNDucGOWila8gWnu8yFfrqmQ45Xq-_39eLKzjRtvpE,516
 learning_loop_node/tests/general/test_data_classes.py,sha256=u5GoXNk2yqCp1EVm9YoBnYreL2SCjgJ0a3x01JQDOuM,701
-learning_loop_node/tests/general/test_downloader.py,sha256=C6b_wG3TfQX53lmuanpH1yaQAdATFGXOmQ1nzXWqNss,3315
+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=nTynYtuUaK2hKh87pk7t7AIJaOiD3wJ5d6nCPqnwRMk,3012
+learning_loop_node/tests/test_helper.py,sha256=Xajn6BWJqeD36YAETwdcJd6awY2NPmaOis3gWgFc97k,2909
 learning_loop_node/tests/trainer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/trainer/conftest.py,sha256=E3SQL_CGFJ_sNjEfVJbxbvH0g6hjI5753ndAFUbnkQk,3366
 learning_loop_node/tests/trainer/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0W5UOnDfGGs_igU,262
@@ -83,13 +84,13 @@ learning_loop_node/trainer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 learning_loop_node/trainer/downloader.py,sha256=Qk-oBcrGCVuWTVs3hvAJzQSqCIHPGZ7NXLJ_fAqvCoY,1469
 learning_loop_node/trainer/exceptions.py,sha256=vbuoE6kssLQuA8zd3LiDHmZglP6E2IJJwEi5AZtWXxY,420
 learning_loop_node/trainer/executor.py,sha256=-0BxDqmAI1NCiISi7Rw8McJQfgxxVy1gSa1epYuL3U0,3942
-learning_loop_node/trainer/io_helpers.py,sha256=hGEtNAQBSBbVB56U1ndwfP8qK5K4YIwMQrjCDcaMy9I,7218
+learning_loop_node/trainer/io_helpers.py,sha256=ZnAPVqhq8XCHe1NoiOQJ_w0B-estcc8CBQHnb423UDw,7226
 learning_loop_node/trainer/rest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/trainer/rest/backdoor_controls.py,sha256=-pU4iHheBWf0SW2QzBVBsLiCMZBRz9CDdVZv6414Ts8,5134
 learning_loop_node/trainer/test_executor.py,sha256=6BVGDN_6f5GEMMEvDLSG1yzMybSvgXaP5uYpSfsVPP0,2224
 learning_loop_node/trainer/trainer_logic.py,sha256=PlYExIskU9pWJO0e9m_0KJnUdOI10GtW0oDOevYmg1o,8461
-learning_loop_node/trainer/trainer_logic_generic.py,sha256=ERfuGhHGNvIPRyd_QOGavylPDXTCC8qCOO1eJXAwEO8,25957
+learning_loop_node/trainer/trainer_logic_generic.py,sha256=zXoi1wWkRy6SGp2sd9xkD2DGd7hiCHxa4NE0RiC71v4,26147
 learning_loop_node/trainer/trainer_node.py,sha256=8ANS9iy-swdTLvt9wEFixE6YlmqvqBl17A-R4tVYD-I,5384
-learning_loop_node-0.10.16.dist-info/METADATA,sha256=ruGCe6Hy4Jfw10X-G2Jza9FCFjBGlqDQ_rZuPbVq3ng,11907
-learning_loop_node-0.10.16.dist-info/WHEEL,sha256=WGfLGfLX43Ei_YORXSnT54hxFygu34kMpcQdmgmEwCQ,88
-learning_loop_node-0.10.16.dist-info/RECORD,,
+learning_loop_node-0.11.0.dist-info/METADATA,sha256=qyWM5Tz1Dp3JfvLhWsdJ-N3C7f2BSspnlfgkADHVmj8,11906
+learning_loop_node-0.11.0.dist-info/WHEEL,sha256=WGfLGfLX43Ei_YORXSnT54hxFygu34kMpcQdmgmEwCQ,88
+learning_loop_node-0.11.0.dist-info/RECORD,,