learning-loop-node 0.10.12__py3-none-any.whl → 0.10.14__py3-none-any.whl

learning_loop_node/annotation/annotator_node.py

@@ -22,7 +22,6 @@ class AnnotatorNode(Node):
         self.tool = annotator_logic
         self.histories: Dict = {}
         annotator_logic.init(self)
-        self.status_sent = False
 
     def register_sio_events(self, sio_client: AsyncClient):
 
@@ -66,8 +65,6 @@ class AnnotatorNode(Node):
         return self.histories.setdefault(frontend_id, self.tool.create_empty_history())
 
     async def send_status(self):
-        if self.status_sent:
-            return
 
         status = AnnotationNodeStatus(
             id=self.uuid,
@@ -76,20 +73,24 @@ class AnnotatorNode(Node):
             capabilities=['segmentation']
         )
 
-        self.log.info(f'Sending status {status}')
+        self.log.debug('Sending status %s', status)
         try:
             result = await self.sio_client.call('update_annotation_node', jsonable_encoder(asdict(status)), timeout=10)
-        except Exception as e:
-            self.log.error(f'Error for updating: {str(e)}')
+        except Exception:
+            self.socket_connection_broken = True
+            self.log.exception('Error for updating:')
+            return
+
+        if not isinstance(result, Dict):
+            self.socket_connection_broken = True
+            self.log.error('Expected Dict, got %s', type(result))
             return
 
-        assert isinstance(result, Dict)
         response = from_dict(data_class=SocketResponse, data=result)
 
         if not response.success:
-            self.log.error(f'Error for updating: Response from loop was : {asdict(response)}')
-        else:
-            self.status_sent = True
+            self.socket_connection_broken = True
+            self.log.error('Response from loop was: %s', asdict(response))
 
     async def download_image(self, context: Context, uuid: str):
         project_folder = create_project_folder(context)

learning_loop_node/data_classes/detections.py

@@ -16,14 +16,14 @@ class BoxDetection():
     """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
-    x: int
-    y: int
-    width: int
-    height: int
-    model_name: str
-    confidence: float
-    category_id: Optional[str] = None
+    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'})
+    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'})
 
     def intersection_over_union(self, other_detection: 'BoxDetection') -> float:
         # https://www.pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/
@@ -52,12 +52,12 @@ class BoxDetection():
 class PointDetection():
     """Coordinates according to COCO format. x,y is the center of the point.
     x increases to the right, y increases downwards."""
-    category_name: str
-    x: float
-    y: float
-    model_name: str
-    confidence: float
-    category_id: Optional[str] = None
+    category_name: str = field(metadata={'description': 'Category name'})
+    x: float = field(metadata={'description': 'X coordinate (right)'})
+    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'})
 
     def distance(self, other: 'PointDetection') -> float:
         return np.sqrt((other.x - self.x)**2 + (other.y - self.y)**2)
@@ -68,10 +68,10 @@ class PointDetection():
 
 @dataclass(**KWONLY_SLOTS)
 class ClassificationDetection():
-    category_name: str
-    model_name: str
-    confidence: float
-    category_id: Optional[str] = None
+    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'})
 
     def __str__(self):
         return f'c: {self.confidence:.2f} -> {self.category_name}'
@@ -112,13 +112,22 @@ def current_datetime():
 
 @dataclass(**KWONLY_SLOTS)
 class Detections():
-    box_detections: List[BoxDetection] = field(default_factory=list)
-    point_detections: List[PointDetection] = field(default_factory=list)
-    segmentation_detections: List[SegmentationDetection] = field(default_factory=list)
-    classification_detections: List[ClassificationDetection] = field(default_factory=list)
-    tags: List[str] = field(default_factory=list)
-    date: Optional[str] = field(default_factory=current_datetime)
-    image_id: Optional[str] = None  # used for detection of trainers
+    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': '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/general.py

@@ -20,14 +20,19 @@ class CategoryType(str, Enum):
 
 @dataclass(**KWONLY_SLOTS)
 class Category():
-    id: str  # TODO: rename to identifier or uuid  (cannot be changed because of database / loop communication)
-    name: str
-    description: Optional[str] = None
-    hotkey: Optional[str] = None
-    color: Optional[str] = None
-    point_size: Optional[int] = None
-    # TODO: rename to ctype (cannot be changed because of database / loop communication)
-    type: Optional[Union[CategoryType, str]] = None
+    id: str = field(metadata={"description": "The uuid of the category."})
+    name: str = field(metadata={"description": "The name of the category."})
+    description: Optional[str] = field(default=None, metadata={
+        "description": "An optional description of the category."})
+    hotkey: Optional[str] = field(default=None, metadata={
+        "description": "The key shortcut of the category when annotating in the Learning Loop UI."})
+    color: Optional[str] = field(default=None, metadata={
+        "description": "The color of the category when displayed in the Learning Loop UI."})
+    point_size: Optional[int] = field(default=None, metadata={
+        "description": "The point size of the category in pixels. Represents the uncertainty of the category."})
+    type: Optional[Union[CategoryType, str]] = field(default=None, metadata={
+        "description": "The type of the category",
+        "example": "box, point, segmentation, classification"})
 
     @staticmethod
     def from_list(values: List[dict]) -> List['Category']:
@@ -45,15 +50,20 @@ class Context():
 
 @dataclass(**KWONLY_SLOTS)
 class ModelInformation():
-    id: str
-    host: Optional[str]
-    organization: str
-    project: str
-    version: str
-    categories: List[Category] = field(default_factory=list)
-    resolution: Optional[int] = None
-    model_root_path: Optional[str] = None
-    model_size: Optional[str] = None
+    id: str = field(metadata={"description": "The uuid of the model."})
+    host: Optional[str] = field(metadata={"description": "The hostname that started the training.",
+                                          "example": "learning-loop.ai"})
+    organization: str = field(metadata={"description": "The owner organization of the model."})
+    project: str = field(metadata={"description": "The project of the model."})
+    version: str = field(metadata={"description": "The version of the model."})
+    categories: List[Category] = field(default_factory=list, metadata={
+                                       "description": "The categories used in the model."})
+    resolution: Optional[int] = field(default=None, metadata={
+        "description": "The resolution of the model (width and height of the image after preprocessing in pixels)."})
+    model_root_path: Optional[str] = field(
+        default=None, metadata={"description": "The path of the parent directory of the model in the file system."})
+    model_size: Optional[str] = field(default=None, metadata={
+                                      "description": "The size of the model (i.e. the specification or variant of the model architecture)."})
 
     @property
     def context(self):

learning_loop_node/data_exchanger.py

@@ -140,20 +140,21 @@ class DataExchanger():
         """Downloads a model (and additional meta data like model.json) and returns the paths of the downloaded files.
         Used before training a model (when continuing a finished training) or before detecting images.
         """
-        logging.info(f'Downloading model data for uuid {model_uuid} from the loop to {target_folder}..')
+        logging.info('Downloading model data for uuid %s from the loop to %s..', model_uuid, target_folder)
 
         path = f'/{context.organization}/projects/{context.project}/models/{model_uuid}/{model_format}/file'
         response = await self.loop_communicator.get(path, requires_login=False)
         if response.status_code != 200:
-            content = response.json()
-            logging.error(f'could not download loop/{path}: {response.status_code}, content: {content}')
-            raise DownloadError(content['detail'])
+            decoded_content = response.content.decode('utf-8')
+            logging.error('could not download loop/%s: %s, content: %s', path,
+                          response.status_code, decoded_content)
+            raise DownloadError(decoded_content)
         try:
             provided_filename = response.headers.get(
                 "Content-Disposition").split("filename=")[1].strip('"')
             content = response.content
         except:
-            logging.exception(f'Error during downloading model {path}:')
+            logging.exception('Error while downloading model %s:', path)
             raise
 
         tmp_path = f'/tmp/{os.path.splitext(provided_filename)[0]}'

learning_loop_node/detector/detector_logic.py

@@ -1,6 +1,6 @@
 import logging
 from abc import abstractmethod
-from typing import Optional
+from typing import List, Optional
 
 import numpy as np
 
@@ -28,7 +28,7 @@ class DetectorLogic():
         return self._model_info is not None
 
     def load_model(self):
-        logging.info(f'Loading model from {GLOBALS.data_folder}/model')
+        logging.info('Loading model from %s', GLOBALS.data_folder)
         model_info = ModelInformation.load_from_disk(f'{GLOBALS.data_folder}/model')
         if model_info is None:
             logging.warning('No model found')
@@ -37,15 +37,21 @@ class DetectorLogic():
         try:
             self._model_info = model_info
             self.init()
-            logging.info(f'Successfully loaded model {self._model_info}')
+            logging.info('Successfully loaded model %s', self._model_info)
         except Exception:
-            logging.error(f'Could not init model {model_info}')
+            logging.error('Could not init model %s', model_info)
             raise
 
     @abstractmethod
     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
+        """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:
         """Evaluate the image and return the detections.

learning_loop_node/detector/detector_node.py

@@ -9,9 +9,9 @@ from threading import Thread
 from typing import Dict, List, Optional, Union
 
 import numpy as np
+import socketio
 from dacite import from_dict
 from fastapi.encoders import jsonable_encoder
-from fastapi_socketio import SocketManager
 from socketio import AsyncClient
 
 from ..data_classes import Category, Context, Detections, DetectionStatus, ModelInformation, Shape
@@ -41,7 +41,7 @@ class DetectorNode(Node):
         self.organization = environment_reader.organization()
         self.project = environment_reader.project()
         assert self.organization and self.project, 'Detector node needs an organization and an project'
-        self.log.info(f'Using {self.organization}/{self.project}')
+        self.log.info('Using %s/%s', self.organization, self.project)
         self.operation_mode: OperationMode = OperationMode.Startup
         self.connected_clients: List[str] = []
 
@@ -70,7 +70,7 @@ class DetectorNode(Node):
         self.include_router(rest_outbox_mode.router, tags=["outbox_mode"])
         self.include_router(rest_version_control.router, tags=["model_version"])
 
-        if use_backdoor_controls:
+        if use_backdoor_controls or os.environ.get('USE_BACKDOOR_CONTROLS', '0').lower() in ('1', 'true'):
             self.include_router(backdoor_controls.router)
 
         self.setup_sio_server()
@@ -93,7 +93,8 @@ class DetectorNode(Node):
         # simulate super().startup
         await self.loop_communicator.backend_ready()
         # await self.loop_communicator.ensure_login()
-        await self.create_sio_client()
+        self.set_skip_repeat_loop(False)
+        self.socket_connection_broken = True
         await self.on_startup()
 
         # simulate startup
@@ -126,35 +127,48 @@ class DetectorNode(Node):
 
     def setup_sio_server(self) -> None:
         """The DetectorNode acts as a SocketIO server. This method sets up the server and defines the event handlers."""
-
         # pylint: disable=unused-argument
 
-        async def _detect(sid, data: Dict) -> Dict:
-            self.log.info('running detect via socketio')
+        # Initialize the Socket.IO server
+        self.sio = socketio.AsyncServer(async_mode='asgi')
+        # Initialize and mount the ASGI app
+        self.sio_app = socketio.ASGIApp(self.sio, socketio_path='/socket.io')
+        self.mount('/ws', self.sio_app)
+        # Register event handlers
+
+        self.log.info('>>>>>>>>>>>>>>>>>>>>>>> Setting up the SIO server')
+
+        @self.sio.event
+        async def detect(sid, data: Dict) -> Dict:
+            self.log.debug('running detect via socketio')
             try:
                 np_image = np.frombuffer(data['image'], np.uint8)
                 det = await self.get_detections(
                     raw_image=np_image,
                     camera_id=data.get('camera-id', None) or data.get('mac', None),
                     tags=data.get('tags', []),
-                    autoupload=data.get('autoupload', None),
+                    source=data.get('source', None),
+                    autoupload=data.get('autoupload', None)
                 )
                 if det is None:
                     return {'error': 'no model loaded'}
-                self.log.info('detect via socketio finished')
-                return det
+                detection_dict = jsonable_encoder(asdict(det))
+                self.log.debug('detect via socketio finished')
+                return detection_dict
             except Exception as e:
                 self.log.exception('could not detect via socketio')
                 with open('/tmp/bad_img_from_socket_io.jpg', 'wb') as f:
                     f.write(data['image'])
                 return {'error': str(e)}
 
-        async def _info(sid) -> Union[str, Dict]:
+        @self.sio.event
+        async def info(sid) -> Union[str, Dict]:
             if self.detector_logic.is_initialized:
                 return asdict(self.detector_logic.model_info)
             return 'No model loaded'
 
-        async def _upload(sid, data: Dict) -> Optional[Dict]:
+        @self.sio.event
+        async def upload(sid, data: Dict) -> Optional[Dict]:
             '''upload an image with detections'''
 
             detection_data = data.get('detections', {})
@@ -171,50 +185,43 @@ class DetectorNode(Node):
             tags = data.get('tags', [])
             tags.append('picked_by_system')
 
+            source = data.get('source', None)
+
             loop = asyncio.get_event_loop()
             try:
-                await loop.run_in_executor(None, self.outbox.save, data['image'], detections, tags)
+                await loop.run_in_executor(None, self.outbox.save, data['image'], detections, tags, source)
             except Exception as e:
                 self.log.exception('could not upload via socketio')
                 return {'error': str(e)}
             return None
 
-        def _connect(sid, environ, auth) -> None:
+        @self.sio.event
+        def connect(sid, environ, auth) -> None:
             self.connected_clients.append(sid)
 
-        print('>>>>>>>>>>>>>>>>>>>>>>> setting up sio server', flush=True)
-
-        self.sio_server = SocketManager(app=self)
-        self.sio_server.on('detect', _detect)
-        self.sio_server.on('info', _info)
-        self.sio_server.on('upload', _upload)
-        self.sio_server.on('connect', _connect)
-
     async def _check_for_update(self) -> None:
-        if self.operation_mode == OperationMode.Startup:
-            return
         try:
-            self.log.info(f'Current operation mode is {self.operation_mode}')
+            self.log.debug('Current operation mode is %s', self.operation_mode)
             try:
                 await self.sync_status_with_learning_loop()
-            except Exception as e:
-                self.log.error(f'Could not check for updates: {e}')
+            except Exception:
+                self.log.exception('Sync with learning loop failed (could not check for updates):')
                 return
 
             if self.operation_mode != OperationMode.Idle:
-                self.log.info(f'not checking for updates; operation mode is {self.operation_mode}')
+                self.log.debug('not checking for updates; operation mode is %s', self.operation_mode)
                 return
 
             self.status.reset_error('update_model')
             if self.target_model is None:
-                self.log.info('not checking for updates; no target model selected')
+                self.log.debug('not checking for updates; no target model selected')
                 return
 
-            current_version = self.detector_logic._model_info.version if self.detector_logic._model_info is not None else None
+            current_version = self.detector_logic._model_info.version if self.detector_logic._model_info is not None else None  # pylint: disable=protected-access
 
             if not self.detector_logic.is_initialized or self.target_model.version != current_version:
-                self.log.info(
-                    f'Current model "{current_version or "-"}" needs to be updated to {self.target_model.version}')
+                self.log.info('Current model "%s" needs to be updated to %s',
+                              current_version or "-", self.target_model.version)
 
                 with step_into(GLOBALS.data_folder):
                     model_symlink = 'model'
@@ -232,7 +239,7 @@ class DetectorNode(Node):
                     except Exception:
                         pass
                     os.symlink(target_model_folder, model_symlink)
-                    self.log.info(f'Updated symlink for model to {os.readlink(model_symlink)}')
+                    self.log.info('Updated symlink for model to %s', os.readlink(model_symlink))
 
                     self.detector_logic.load_model()
                     try:
@@ -283,13 +290,16 @@ class DetectorNode(Node):
             model_format=self.detector_logic.model_format,
         )
 
-        self.log.info(f'sending status {status}')
+        self.log.debug('sending status %s', status)
         response = await self.sio_client.call('update_detector', (self.organization, self.project, jsonable_encoder(asdict(status))))
+        if not response:
+            self.socket_connection_broken = True
+            return
 
-        assert response is not None
         socket_response = from_dict(data_class=SocketResponse, data=response)
         if not socket_response.success:
-            self.log.error(f'Statusupdate failed: {response}')
+            self.socket_connection_broken = True
+            self.log.error('Statusupdate failed: %s', response)
             raise Exception(f'Statusupdate failed: {response}')
 
         assert socket_response.payload is not None
@@ -301,21 +311,24 @@ class DetectorNode(Node):
                                                        id=deployment_target_model_id,
                                                        version=deployment_target_model_version)
 
-        if self.version_control == rest_version_control.VersionMode.FollowLoop:
+        if (self.version_control == rest_version_control.VersionMode.FollowLoop and
+                self.target_model != self.loop_deployment_target):
+            old_target_model_version = self.target_model.version if self.target_model else None
             self.target_model = self.loop_deployment_target
-            self.log.info(f'After sending status. Target_model is {self.target_model.version}')
+            self.log.info('After sending status. Target_model changed from %s to %s',
+                          old_target_model_version, self.target_model.version)
 
     async def set_operation_mode(self, mode: OperationMode):
         self.operation_mode = mode
         try:
             await self.sync_status_with_learning_loop()
         except Exception as e:
-            self.log.warning(f'Operation mode set to {mode}, but sync failed: {e}')
+            self.log.warning('Operation mode set to %s, but sync failed: %s', mode, e)
 
     def reload(self, reason: str):
         '''provide a cause for the reload'''
 
-        self.log.info(f'########## reloading app because {reason}')
+        self.log.info('########## reloading app because %s', reason)
         if os.path.isfile('/app/app_code/restart/restart.py'):
             subprocess.call(['touch', '/app/app_code/restart/restart.py'])
         elif os.path.isfile('/app/main.py'):
@@ -325,33 +338,37 @@ class DetectorNode(Node):
         else:
             self.log.error('could not reload app')
 
-    async def get_detections(self, raw_image: np.ndarray, camera_id: Optional[str], tags: List[str], autoupload: Optional[str] = None) -> Optional[Dict]:
-        """Note: raw_image is a numpy array of type uint8, but not in the correrct shape!
+    async def get_detections(self,
+                             raw_image: np.ndarray,
+                             camera_id: Optional[str],
+                             tags: List[str],
+                             source: Optional[str] = None,
+                             autoupload: Optional[str] = None) -> Detections:
+        """ 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!
         It can be converted e.g. using cv2.imdecode(raw_image, cv2.IMREAD_COLOR)"""
-        loop = asyncio.get_event_loop()
+
         await self.detection_lock.acquire()
-        detections: Detections = await loop.run_in_executor(None, self.detector_logic.evaluate, raw_image)
+        loop = asyncio.get_event_loop()
+        detections = await loop.run_in_executor(None, self.detector_logic.evaluate_with_all_info, raw_image, tags, source)
         self.detection_lock.release()
-        for seg_detection in detections.segmentation_detections:
-            if isinstance(seg_detection.shape, Shape):
-                shapes = ','.join([str(value) for p in seg_detection.shape.points for _,
-                                   value in asdict(p).items()])
-                seg_detection.shape = shapes  # TODO This seems to be a quick fix.. check how loop upload detections deals with this
 
+        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)
-        self.log.info(f'detected:{n_bo} boxes, {n_po} points, {n_se} segs, {n_cl} classes')
+        self.log.debug('Detected: %d boxes, %d points, %d segs, %d classes', n_bo, n_po, n_se, n_cl)
 
         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)).start()
+                   args=(detections, camera_id, raw_image, tags, source)).start()
         elif autoupload == 'all':
-            Thread(target=self.outbox.save, args=(raw_image, detections, tags)).start()
+            Thread(target=self.outbox.save, args=(raw_image, detections, tags, source)).start()
         elif autoupload == 'disabled':
             pass
         else:
-            self.log.error(f'unknown autoupload value {autoupload}')
-        return jsonable_encoder(asdict(detections))
+            self.log.error('unknown autoupload value %s', autoupload)
+        return detections
 
     async def upload_images(self, images: List[bytes]):
         loop = asyncio.get_event_loop()
@@ -393,3 +410,12 @@ def step_into(new_dir):
         yield
     finally:
         os.chdir(previous_dir)
+
+
+def fix_shape_detections(detections: Detections):
+    # 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):
+            points = ','.join([str(value) for p in seg_detection.shape.points for _,
+                               value in asdict(p).items()])
+            seg_detection.shape = points

learning_loop_node/detector/inbox_filter/relevance_filter.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from ...data_classes.detections import Detections
 from ..outbox import Outbox
@@ -11,7 +11,13 @@ class RelevanceFilter():
         self.cam_histories: Dict[str, CamObservationHistory] = {}
         self.outbox: Outbox = outbox
 
-    def may_upload_detections(self, dets: Detections, cam_id: str, raw_image: bytes, tags: List[str]) -> List[str]:
+    def may_upload_detections(self,
+                              dets: Detections,
+                              cam_id: str,
+                              raw_image: bytes,
+                              tags: List[str],
+                              source: Optional[str] = None
+                              ) -> List[str]:
         for group in self.cam_histories.values():
             group.forget_old_detections()
 
@@ -23,5 +29,5 @@ class RelevanceFilter():
         if len(causes) > 0:
             tags = tags if tags is not None else []
             tags.extend(causes)
-            self.outbox.save(raw_image, dets, tags)
+            self.outbox.save(raw_image, dets, tags, source)
         return causes

learning_loop_node/detector/outbox.py

@@ -55,7 +55,13 @@ class Outbox():
 
         self.upload_counter = 0
 
-    def save(self, image: bytes, detections: Optional[Detections] = None, tags: Optional[List[str]] = None) -> None:
+    def save(self,
+             image: bytes,
+             detections: Optional[Detections] = None,
+             tags: Optional[List[str]] = None,
+             source: Optional[str] = None
+             ) -> None:
+
         if not self._is_valid_jpg(image):
             self.log.error('Invalid jpg image')
             return
@@ -71,6 +77,7 @@ class Outbox():
         tmp = f'{GLOBALS.data_folder}/tmp/{identifier}'
         detections.tags = tags
         detections.date = identifier
+        detections.source = source or 'unknown'
         os.makedirs(tmp, exist_ok=True)
 
         with open(tmp + '/image.json', 'w') as f: