learning-loop-node 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

learning_loop_node/annotation/annotator_node.py

@@ -18,7 +18,7 @@ from .annotator_logic import AnnotatorLogic
 class AnnotatorNode(Node):
 
     def __init__(self, name: str, annotator_logic: AnnotatorLogic, uuid: Optional[str] = None):
-        super().__init__(name, uuid, 'annotation_node')
+        super().__init__(name, uuid=uuid, node_type='annotation_node')
         self.tool = annotator_logic
         self.histories: Dict = {}
         annotator_logic.init(self)
@@ -35,6 +35,9 @@ class AnnotatorNode(Node):
             return self.tool.logout_user(sid)
 
     async def _handle_user_input(self, user_input_dict: Dict) -> str:
+        if not self.sio_client or not self.sio_client.connected:
+            raise ConnectionError('SocketIO client is not connected')
+
         user_input = from_dict(data_class=UserInput, data=user_input_dict)
 
         if user_input.data.key_up == 'Escape':
@@ -66,6 +69,9 @@ class AnnotatorNode(Node):
 
     async def send_status(self):
 
+        if not self.sio_client or not self.sio_client.connected:
+            raise ConnectionError('SocketIO client is not connected')
+
         status = AnnotationNodeStatus(
             id=self.uuid,
             name=self.name,

learning_loop_node/data_classes/__init__.py

@@ -1,18 +1,44 @@
 from .annotations import AnnotationData, SegmentationAnnotation, ToolOutput, UserInput
-from .detections import (BoxDetection, ClassificationDetection, Detections, Observation, Point, PointDetection,
-                         SegmentationDetection, Shape)
-from .general import (AboutResponse, AnnotationNodeStatus, Category, Context, DetectionStatus, ErrorConfiguration,
-                      ModelInformation, ModelVersionResponse, NodeState, NodeStatus)
-from .image_metadata import ImageMetadata
+from .detections import (
+    BoxDetection,
+    ClassificationDetection,
+    Detections,
+    Observation,
+    Point,
+    PointDetection,
+    SegmentationDetection,
+    Shape,
+)
+from .general import (
+    AboutResponse,
+    AnnotationNodeStatus,
+    Category,
+    Context,
+    DetectorStatus,
+    ErrorConfiguration,
+    ModelInformation,
+    ModelVersionResponse,
+    NodeState,
+    NodeStatus,
+)
+from .image_metadata import ImageMetadata, ImagesMetadata
 from .socket_response import SocketResponse
-from .training import Errors, PretrainedModel, Training, TrainingError, TrainingOut, TrainingStateData, TrainingStatus
+from .training import (
+    Errors,
+    PretrainedModel,
+    Training,
+    TrainingError,
+    TrainingOut,
+    TrainingStateData,
+    TrainingStatus,
+)
 
 __all__ = [
     'AboutResponse', 'AnnotationData', 'SegmentationAnnotation', 'ToolOutput', 'UserInput',
     'BoxDetection', 'ClassificationDetection', 'ImageMetadata', 'Observation', 'Point', 'PointDetection',
     'SegmentationDetection', 'Shape', 'Detections',
-    'AnnotationNodeStatus', 'Category', 'Context', 'DetectionStatus', 'ErrorConfiguration',
-    'ModelInformation', 'NodeState', 'NodeStatus', 'ModelVersionResponse',
+    'AnnotationNodeStatus', 'Category', 'Context', 'DetectorStatus', 'ErrorConfiguration',
+    'ModelInformation', 'NodeState', 'NodeStatus', 'ModelVersionResponse', 'ImagesMetadata',
     'SocketResponse',
     'Errors', 'PretrainedModel', 'Training',
     'TrainingError', 'TrainingOut', 'TrainingStateData', 'TrainingStatus',

learning_loop_node/data_classes/general.py

@@ -148,8 +148,8 @@ class NodeState(str, Enum):
 class NodeStatus():
     id: str
     name: str
-    state: Optional[NodeState] = NodeState.Online
-    uptime: Optional[int] = 0
+    state: NodeState = NodeState.Online
+    uptime: int = 0
     errors: Dict = field(default_factory=dict)
     capabilities: List[str] = field(default_factory=list)
 
@@ -175,14 +175,13 @@ class AnnotationNodeStatus(NodeStatus):
 
 
 @dataclass(**KWONLY_SLOTS)
-class DetectionStatus():
-    id: str
+class DetectorStatus():
+    uuid: str
     name: str
+    state: NodeState
+    uptime: int
     model_format: str
-
-    state: Optional[NodeState] = None
-    errors: Optional[Dict] = None
-    uptime: Optional[int] = None
-    current_model: Optional[str] = None
-    target_model: Optional[str] = None
-    operation_mode: Optional[str] = None
+    current_model: Optional[str]
+    target_model: Optional[str]
+    errors: Dict
+    operation_mode: str

learning_loop_node/data_classes/image_metadata.py

@@ -35,3 +35,8 @@ class ImageMetadata():
 
     def __len__(self):
         return len(self.box_detections) + len(self.point_detections) + len(self.segmentation_detections) + len(self.classification_detections)
+
+
+@dataclass(**KWONLY_SLOTS)
+class ImagesMetadata():
+    items: List[ImageMetadata] = field(default_factory=list, metadata={'description': 'List of image metadata'})

learning_loop_node/data_classes/training.py

@@ -8,6 +8,7 @@ from uuid import uuid4
 
 from ..enums import TrainerState
 from ..helpers.misc import create_image_folder, create_training_folder
+
 # pylint: disable=no-name-in-module
 from .general import Category, Context
 
@@ -52,7 +53,7 @@ class Training():
     training_folder: str  # f'{project_folder}/trainings/{trainings_id}'
 
     categories: List[Category]
-    hyperparameters: dict
+    hyperparameters: Dict[str, Any]
 
     training_number: int
     training_state: str
@@ -63,7 +64,7 @@ class Training():
     base_model_uuid: Optional[str] = None  # model uuid to continue training (is loaded from loop)
 
     # NOTE: these are set later after the model has been uploaded
-    image_data: Optional[List[dict]] = None
+    image_data: Optional[List[Dict]] = None
     skipped_image_count: Optional[int] = None
     model_uuid_for_detecting: Optional[str] = None  # Model uuid to load from the loop after training and upload
 

learning_loop_node/data_exchanger.py

@@ -7,7 +7,7 @@ from glob import glob
 from http import HTTPStatus
 from io import BytesIO
 from time import time
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 import aiofiles  # type: ignore
 
@@ -68,7 +68,7 @@ class DataExchanger():
         assert response.status_code == 200, response
         return (response.json())['image_ids']
 
-    async def download_images_data(self, image_uuids: List[str], chunk_size: int = 100) -> List[Dict]:
+    async def download_images_data(self, image_uuids: List[str], chunk_size: int = 100) -> List[Dict[str, Any]]:
         """Download image annotations, tags, set and other information for the given image uuids."""
         logging.info('Fetching annotations, tags, sets, etc. for %s images..', len(image_uuids))
 
@@ -78,7 +78,7 @@ class DataExchanger():
             return []
 
         progress_factor = 0.5 / num_image_ids  # first 50% of progress is for downloading data
-        images_data: List[Dict] = []
+        images_data: List[Dict[str, Any]] = []
         for i in range(0, num_image_ids, chunk_size):
             self.progress = i * progress_factor
             chunk_ids = image_uuids[i:i+chunk_size]

learning_loop_node/detector/detector_logic.py

@@ -2,7 +2,7 @@ import logging
 from abc import abstractmethod
 from typing import List, Optional
 
-from ..data_classes import ImageMetadata, ModelInformation
+from ..data_classes import ImageMetadata, ImagesMetadata, ModelInformation
 from ..globals import GLOBALS
 from .exceptions import NodeNeedsRestartError
 
@@ -52,3 +52,8 @@ class DetectorLogic():
     def evaluate(self, image: bytes) -> ImageMetadata:
         """Evaluate the image and return the detections.
         The object should return empty detections if it 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"""

learning_loop_node/detector/detector_node.py

@@ -6,9 +6,8 @@ import subprocess
 import sys
 from dataclasses import asdict
 from datetime import datetime
-from typing import Dict, List, Optional, cast
+from typing import Dict, List, Optional
 
-import numpy as np
 import socketio
 from dacite import from_dict
 from fastapi.encoders import jsonable_encoder
@@ -18,13 +17,13 @@ from ..data_classes import (
     AboutResponse,
     Category,
     Context,
-    DetectionStatus,
+    DetectorStatus,
     ImageMetadata,
+    ImagesMetadata,
     ModelInformation,
     ModelVersionResponse,
     Shape,
 )
-from ..data_classes.socket_response import SocketResponse
 from ..data_exchanger import DataExchanger, DownloadError
 from ..enums import OperationMode, VersionMode
 from ..globals import GLOBALS
@@ -46,7 +45,7 @@ from .rest import upload as rest_upload
 class DetectorNode(Node):
 
     def __init__(self, name: str, detector: DetectorLogic, uuid: Optional[str] = None, use_backdoor_controls: bool = False) -> None:
-        super().__init__(name, uuid, 'detector', False)
+        super().__init__(name, uuid=uuid, node_type='detector', needs_login=False, needs_sio=False)
         self.detector_logic = detector
         self.organization = environment_reader.organization()
         self.project = environment_reader.project()
@@ -73,6 +72,10 @@ class DetectorNode(Node):
         self.target_model: Optional[ModelInformation] = None
         self.loop_deployment_target: Optional[ModelInformation] = None
 
+        self._regular_status_sync_cycles: int = int(os.environ.get('SYNC_CYCLES', '6'))
+        """sync status every 6 cycles (6*10s = 1min)"""
+        self._repeat_cycles_to_next_sync: int = 0
+
         self.include_router(rest_detect.router, tags=["detect"])
         self.include_router(rest_upload.router, prefix="")
         self.include_router(rest_mode.router, tags=["operation_mode"])
@@ -83,7 +86,7 @@ class DetectorNode(Node):
         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()
+        self._setup_sio_server()
 
     def get_about_response(self) -> AboutResponse:
         return AboutResponse(
@@ -199,13 +202,7 @@ class DetectorNode(Node):
         except Exception:
             self.log.exception("error during 'shutdown'")
 
-    async def on_repeat(self) -> None:
-        try:
-            await self._check_for_update()
-        except Exception:
-            self.log.exception("error during '_check_for_update'")
-
-    def setup_sio_server(self) -> None:
+    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
 
@@ -238,8 +235,29 @@ class DetectorNode(Node):
                 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'])
+                # with open('/tmp/bad_img_from_socket_io.jpg', 'wb') as f:
+                #     f.write(data['image'])
+                return {'error': str(e)}
+
+        @self.sio.event
+        async def batch_detect(sid, data: Dict) -> Dict:
+            try:
+                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),
+                    source=data.get('source', None),
+                    autoupload=data.get('autoupload', None),
+                    creation_date=data.get('creation_date', None)
+                )
+                if det is None:
+                    return {'error': 'no model loaded'}
+                detection_dict = jsonable_encoder(asdict(det))
+                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)}
 
         @self.sio.event
@@ -310,96 +328,22 @@ class DetectorNode(Node):
         def connect(sid, environ, auth) -> None:
             self.connected_clients.append(sid)
 
-    async def _check_for_update(self) -> None:
-        try:
-            self.log.debug('Current operation mode is %s', self.operation_mode)
-            try:
-                await self.sync_status_with_learning_loop()
-            except Exception:
-                self.log.exception('Sync with learning loop failed (could not check for updates):')
-                return
+# ================================== Repeat Cycle, sync and model updates ==================================
 
-            if self.operation_mode != OperationMode.Idle:
-                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.debug('not checking for updates; no target model selected')
-                return
-
-            if self.detector_logic.model_info is not None:
-                current_version = self.detector_logic.model_info.version
-            else:
-                current_version = None
-
-            if current_version != 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'
-                    target_model_folder = f'models/{self.target_model.version}'
-                    if os.path.exists(target_model_folder) and len(os.listdir(target_model_folder)) > 0:
-                        self.log.info('No need to download model %s (already exists)', self.target_model.version)
-                    else:
-                        os.makedirs(target_model_folder, exist_ok=True)
-                        try:
-                            await self.data_exchanger.download_model(target_model_folder,
-                                                                     Context(organization=self.organization,
-                                                                             project=self.project),
-                                                                     self.target_model.id,
-                                                                     self.detector_logic.model_format)
-                            self.log.info('Downloaded model %s', self.target_model.version)
-                        except Exception:
-                            self.log.exception('Could not download model %s', self.target_model.version)
-                            shutil.rmtree(target_model_folder, ignore_errors=True)
-                            return
-                    try:
-                        os.unlink(model_symlink)
-                        os.remove(model_symlink)
-                    except Exception:
-                        pass
-                    os.symlink(target_model_folder, model_symlink)
-                    self.log.info('Updated symlink for model to %s', os.readlink(model_symlink))
-
-                    try:
-                        self.detector_logic.load_model_info_and_init_model()
-                    except NodeNeedsRestartError:
-                        self.log.error('Node needs restart')
-                        sys.exit(0)
-                    except Exception:
-                        self.log.exception('Could not load model, will retry download on next check')
-                        shutil.rmtree(target_model_folder, ignore_errors=True)
-                        return
-                    try:
-                        await self.sync_status_with_learning_loop()
-                    except Exception:
-                        pass
-                    # self.reload(reason='new model installed')
-
-        except Exception as e:
-            self.log.exception('check_for_update failed')
-            msg = e.cause if isinstance(e, DownloadError) else str(e)
-            self.status.set_error('update_model', f'Could not update model: {msg}')
-            try:
-                await self.sync_status_with_learning_loop()
-            except Exception:
-                pass
-
-    async def sync_status_with_learning_loop(self) -> None:
-        """Sync status of the detector with the Learning Loop.
-        The Learning Loop will respond with the model info of the deployment target.
-        If version_control is set to FollowLoop, the detector will update the target_model.
-        Return if the communication was successful.
-
-        Raises:
-            Exception: If the communication with the Learning Loop failed.
-        """
+    async def on_repeat(self) -> None:
+        """Implementation of the repeat cycle. This method is called every 10 seconds.
+        To avoid too many requests, the status is only synced every 6 cycles (1 minute)."""
+        try:
+            self._repeat_cycles_to_next_sync -= 1
+            if self._repeat_cycles_to_next_sync <= 0:
+                self._repeat_cycles_to_next_sync = self._regular_status_sync_cycles
+                await self._sync_status_with_loop()
+            await self._update_model_if_required()
+        except Exception:
+            self.log.exception("error during '_check_for_update'")
 
-        if not self.sio_client.connected:
-            self.log.info('Status sync failed: not connected')
-            raise Exception('Status sync failed: not connected')
+    async def _sync_status_with_loop(self) -> None:
+        """Sync status of the detector with the Learning Loop."""
 
         if self.detector_logic.model_info is not None:
             current_model = self.detector_logic.model_info.version
@@ -408,8 +352,8 @@ class DetectorNode(Node):
 
         target_model_version = self.target_model.version if self.target_model else None
 
-        status = DetectionStatus(
-            id=self.uuid,
+        status = DetectorStatus(
+            uuid=self.uuid,
             name=self.name,
             state=self.status.state,
             errors=self.status.errors,
@@ -420,49 +364,128 @@ class DetectorNode(Node):
             model_format=self.detector_logic.model_format,
         )
 
-        self.log_status_on_change(status.state or 'None', status)
+        self.log_status_on_change(status.state, status)
+
+        try:
+            response = await self.loop_communicator.post(
+                f'/{self.organization}/projects/{self.project}/detectors', json=jsonable_encoder(asdict(status)))
+        except Exception:
+            self.log.warning('Exception while trying to sync status with loop')
+
+        if response.status_code != 200:
+            self.log.warning('Status update failed: %s', str(response))
+
+    async def _update_model_if_required(self) -> None:
+        """Check if a new model is available and update if necessary.
+        The Learning Loop will respond with the model info of the deployment target.
+        If version_control is set to FollowLoop or the chosen target model is not used, 
+        the detector will update the target_model."""
+        try:
+            if self.operation_mode != OperationMode.Idle:
+                self.log.debug('not checking for updates; operation mode is %s', self.operation_mode)
+                return
+
+            await self._check_for_new_deployment_target()
+
+            self.status.reset_error('update_model')
+            if self.target_model is None:
+                self.log.debug('not running any updates; target model is None')
+                return
+
+            current_version = self.detector_logic.model_info.version \
+                if self.detector_logic.model_info is not None else None
+
+            if current_version != self.target_model.version:
+                self.log.info('Updating model from %s to %s',
+                              current_version or "-", self.target_model.version)
+                await self._update_model(self.target_model)
+
+        except Exception as e:
+            self.log.exception('check_for_update failed')
+            msg = e.cause if isinstance(e, DownloadError) else str(e)
+            self.status.set_error('update_model', f'Could not update model: {msg}')
+            await self._sync_status_with_loop()
 
-        # NOTE: sending organization and project is no longer required!
+    async def _check_for_new_deployment_target(self) -> None:
+        """Ask the learning loop for the current deployment target and update self.loop_deployment_target.
+        If version_control is set to FollowLoop, also update target_model."""
         try:
-            response = await self.sio_client.call('update_detector', (self.organization, self.project, jsonable_encoder(asdict(status))))
-        except TimeoutError:
-            self.socket_connection_broken = True
-            self.log.exception('TimeoutError for sending status update (will try to reconnect):')
-            raise Exception('Status update failed due to timeout') from None
-
-        if not response:
-            self.socket_connection_broken = True
-            self.log.error('Status update failed (will try to reconnect): %s', response)
-            raise Exception('Status update failed: Did not receive a response from the learning loop')
-
-        socket_response = from_dict(data_class=SocketResponse, data=response)
-        if not socket_response.success:
-            self.socket_connection_broken = True
-            self.log.error('Status update failed (will try to reconnect): %s', response)
-            raise Exception(f'Status update failed. Response from learning loop: {response}')
-
-        assert socket_response.payload is not None
-
-        deployment_target_model_id = socket_response.payload['target_model_id']
-        deployment_target_model_version = socket_response.payload['target_model_version']
+            response = await self.loop_communicator.get(
+                f'/{self.organization}/projects/{self.project}/deployment/target')
+        except Exception:
+            self.log.warning('Exception while trying to check for new deployment target')
+            return
+
+        if response.status_code != 200:
+            self.log.warning('Failed to check for new deployment target: %s', str(response))
+            return
+
+        response_data = response.json()
+
+        deployment_target_uuid = response_data['model_uuid']
+        deployment_target_version = response_data['version']
         self.loop_deployment_target = ModelInformation(organization=self.organization, project=self.project,
                                                        host="", categories=[],
-                                                       id=deployment_target_model_id,
-                                                       version=deployment_target_model_version)
+                                                       id=deployment_target_uuid,
+                                                       version=deployment_target_version)
 
         if (self.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
+            previous_version = self.target_model.version if self.target_model else None
             self.target_model = self.loop_deployment_target
-            self.log.info('After sending status. Target_model changed from %s to %s',
-                          old_target_model_version, self.target_model.version)
+            self.log.info('Deployment target changed from %s to %s',
+                          previous_version, self.target_model.version)
+
+    async def _update_model(self, target_model: ModelInformation) -> None:
+        """Download and install the target model.
+        On failure, the target_model will be set to None which will trigger a retry on the next check."""
+
+        with step_into(GLOBALS.data_folder):
+            target_model_folder = f'models/{target_model.version}'
+            if os.path.exists(target_model_folder) and len(os.listdir(target_model_folder)) > 0:
+                self.log.info('No need to download model. %s (already exists)', target_model.version)
+            else:
+                os.makedirs(target_model_folder, exist_ok=True)
+                try:
+                    await self.data_exchanger.download_model(target_model_folder,
+                                                             Context(organization=self.organization,
+                                                                     project=self.project),
+                                                             target_model.id, self.detector_logic.model_format)
+                    self.log.info('Downloaded model %s', target_model.version)
+                except Exception:
+                    self.log.exception('Could not download model %s', target_model.version)
+                    shutil.rmtree(target_model_folder, ignore_errors=True)
+                    self.target_model = None
+                    return
+
+            model_symlink = 'model'
+            try:
+                os.unlink(model_symlink)
+                os.remove(model_symlink)
+            except Exception:
+                pass
+            os.symlink(target_model_folder, model_symlink)
+            self.log.info('Updated symlink for model to %s', os.readlink(model_symlink))
+
+            try:
+                self.detector_logic.load_model_info_and_init_model()
+            except NodeNeedsRestartError:
+                self.log.error('Node needs restart')
+                sys.exit(0)
+            except Exception:
+                self.log.exception('Could not load model, will retry download on next check')
+                shutil.rmtree(target_model_folder, ignore_errors=True)
+                self.target_model = None
+                return
+
+            await self._sync_status_with_loop()
+            # self.reload(reason='new model installed')
+
+# ================================== API Implementations ==================================
 
     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('Operation mode set to %s, but sync failed: %s', mode, e)
+        await self._sync_status_with_loop()
 
     def reload(self, reason: str):
         """provide a cause for the reload"""
@@ -479,13 +502,14 @@ class DetectorNode(Node):
 
     async def get_detections(self,
                              raw_image: bytes,
-                             camera_id: Optional[str],
                              tags: List[str],
+                             *,
+                             camera_id: Optional[str] = None,
                              source: Optional[str] = None,
                              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.
+        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)"""
 
@@ -511,6 +535,40 @@ class DetectorNode(Node):
             self.log.error('unknown autoupload value %s', autoupload)
         return detections
 
+    async def get_batch_detections(self,
+                                   raw_images: List[bytes],
+                                   tags: List[str],
+                                   *,
+                                   camera_id: Optional[str] = None,
+                                   source: Optional[str] = None,
+                                   autoupload: Optional[str] = None,
+                                   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."""
+
+        await self.detection_lock.acquire()
+        all_detections = await run.io_bound(self.detector_logic.batch_evaluate, raw_images)
+        self.detection_lock.release()
+
+        for detections, raw_image in zip(all_detections.items, raw_images):
+            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.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
+                ))
+            elif autoupload == 'all':
+                background_tasks.create(self.outbox.save(raw_image, detections, tags, source, creation_date))
+            elif autoupload == 'disabled':
+                pass
+            else:
+                self.log.error('unknown autoupload value %s', autoupload)
+        return all_detections
+
     async def upload_images(
             self, *,
             images: List[bytes],

learning_loop_node/detector/outbox.py

@@ -189,7 +189,7 @@ class Outbox():
 
     async def _continuous_upload(self) -> None:
         self.log.info('continuous upload started')
-        assert self.shutdown_event is not None
+        assert self.shutdown_event is not None, 'shutdown_event is None'
         while not self.shutdown_event.is_set():
             await self.upload()
             await asyncio.sleep(self.UPLOAD_INTERVAL_S)
@@ -287,7 +287,7 @@ class Outbox():
             return True
 
         try:
-            assert self.shutdown_event is not None
+            assert self.shutdown_event is not None, 'shutdown_event is None'
             self.shutdown_event.set()
             await asyncio.wait_for(self.upload_task, timeout=self.UPLOAD_TIMEOUT_S + 1)
         except asyncio.TimeoutError: