learning-loop-node 0.17.1__tar.gz → 0.18.0__tar.gz

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learning-loop-node
-Version: 0.17.1
+Version: 0.18.0
 Summary: Python Library for Nodes which connect to the Zauberzeug Learning Loop
 Home-page: https://github.com/zauberzeug/learning_loop_node
 License: MIT
@@ -21,7 +21,7 @@ Requires-Dist: dacite (>=1.8.1,<2.0.0)
 Requires-Dist: fastapi (>=0.93,<0.109)
 Requires-Dist: fastapi-socketio (>=0.0.10,<0.0.11)
 Requires-Dist: fastapi-utils (>=0.2.1,<0.3.0)
-Requires-Dist: httpx (>=0.24.1,<0.25.0)
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
 Requires-Dist: icecream (>=2.1.0,<3.0.0)
 Requires-Dist: numpy (>=1.13.3,<2.0.0)
 Requires-Dist: psutil (>=5.8.0,<6.0.0)
@@ -90,9 +90,8 @@ Detector Nodes are normally deployed on edge devices like robots or machinery bu
 Images can be send to the detector node via socketio or rest.
 Via **REST** you may provide the following parameters:
 
-- `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled`
 - `camera_id`: a camera identifier (string) used to improve the autoupload filtering
-- `tags`: comma separated list of tags to add to the image in the learning loop
+- `tags`: comma separated list of tags to add to the image in the learning loop to add to the image in the learning loop
 - `source`: optional source identifier (str) for the image (e.g. a robot id)
 - `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled`
 - `creation_date`: optional creation date (str) for the image in isoformat (e.g. `2023-01-30T12:34:56`)
@@ -101,7 +100,22 @@ Example usage:
 
 `curl --request POST -F 'file=@test.jpg' -H 'autoupload: all' -H 'camera_id: front_cam' localhost:8004/detect`
 
-To use the **SocketIO** inference EPs, the caller needs to connect to the detector node's SocketIO server and emit the `detect` or `batch_detect` event with the image data and image metadata.
+To use the **SocketIO** inference EPs, the caller needs to connect to the detector node's SocketIO server and emit the `detect` or `batch_detect` event with the image data and image metadata. The `detect` endpoint receives a dictionary, with the following entries:
+
+- `image`: The image data as dictionary with the following keys:
+  - `bytes`: bytes of the ndarray (retrieved via `ndarray.tobytes(order='C')`)
+  - `dtype`: data type of the ndarray as string (e.g. `uint8`, `float32`, etc.)
+  - `shape`: shape of the ndarray as tuple of ints (e.g. `(480, 640, 3)`)
+- `camera_id`: optional camera identifier (string) used to improve the autoupload filtering
+- `tags`: optional list of tags to add to the image in the learning loop
+- `source`: optional source string
+- `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled`
+- `creation_date`: optional creation date (str) for the image in isoformat (e.g. `2023-01-30T12:34:56`)
+
+The `batch_detect` endpoint receives a dictionary, with the same entries as the `detect` endpoint, except that the `image` entry is replaced by:
+
+- `images`: List of image data dictionaries, each with the same structure as the `image` entry in the `detect` endpoint
+
 Example code can be found [in the rosys implementation](https://github.com/zauberzeug/rosys/blob/main/rosys/vision/detector_hardware.py).
 
 ### Upload API
@@ -116,12 +130,14 @@ Example:
 
 `curl -X POST -F 'files=@test.jpg' "http://localhost:/upload"`
 
-The detector also has a **SocketIO** upload endpoint that can be used to upload images and detections to the learning loop. The function receives a json dictionary, with the following entries:
-
-- `image`: the image data in jpg format
+The detector also has a **SocketIO** upload endpoint that can be used to upload images and detections to the learning loop. The function receives a dictionary, with the following entries:
 
+- `image`: the image data as dictionary with the following keys:
+  - `bytes`: bytes of the ndarray (retrieved via `ndarray.tobytes(order='C')`)
+  - `dtype`: data type of the ndarray as string (e.g. `uint8`, `float32`, etc.)
+  - `shape`: shape of the ndarray as tuple of ints (e.g. `(480, 640, 3)`)
 - `metadata`: a dictionary representing the image metadata. If metadata contains detections and/or annotations, UUIDs for the classes are automatically determined based on the category names. Metadata should follow the schema of the `ImageMetadata` data class.
-- `upload_priority`: boolean flag to prioritize the upload (defaults to False)
+- `upload_priority`: Optional boolean flag to prioritize the upload (defaults to False)
 
 The endpoint returns None if the upload was successful and an error message otherwise.
 

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/README.md

@@ -50,9 +50,8 @@ Detector Nodes are normally deployed on edge devices like robots or machinery bu
 Images can be send to the detector node via socketio or rest.
 Via **REST** you may provide the following parameters:
 
-- `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled`
 - `camera_id`: a camera identifier (string) used to improve the autoupload filtering
-- `tags`: comma separated list of tags to add to the image in the learning loop
+- `tags`: comma separated list of tags to add to the image in the learning loop to add to the image in the learning loop
 - `source`: optional source identifier (str) for the image (e.g. a robot id)
 - `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled`
 - `creation_date`: optional creation date (str) for the image in isoformat (e.g. `2023-01-30T12:34:56`)
@@ -61,7 +60,22 @@ Example usage:
 
 `curl --request POST -F 'file=@test.jpg' -H 'autoupload: all' -H 'camera_id: front_cam' localhost:8004/detect`
 
-To use the **SocketIO** inference EPs, the caller needs to connect to the detector node's SocketIO server and emit the `detect` or `batch_detect` event with the image data and image metadata.
+To use the **SocketIO** inference EPs, the caller needs to connect to the detector node's SocketIO server and emit the `detect` or `batch_detect` event with the image data and image metadata. The `detect` endpoint receives a dictionary, with the following entries:
+
+- `image`: The image data as dictionary with the following keys:
+  - `bytes`: bytes of the ndarray (retrieved via `ndarray.tobytes(order='C')`)
+  - `dtype`: data type of the ndarray as string (e.g. `uint8`, `float32`, etc.)
+  - `shape`: shape of the ndarray as tuple of ints (e.g. `(480, 640, 3)`)
+- `camera_id`: optional camera identifier (string) used to improve the autoupload filtering
+- `tags`: optional list of tags to add to the image in the learning loop
+- `source`: optional source string
+- `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled`
+- `creation_date`: optional creation date (str) for the image in isoformat (e.g. `2023-01-30T12:34:56`)
+
+The `batch_detect` endpoint receives a dictionary, with the same entries as the `detect` endpoint, except that the `image` entry is replaced by:
+
+- `images`: List of image data dictionaries, each with the same structure as the `image` entry in the `detect` endpoint
+
 Example code can be found [in the rosys implementation](https://github.com/zauberzeug/rosys/blob/main/rosys/vision/detector_hardware.py).
 
 ### Upload API
@@ -76,12 +90,14 @@ Example:
 
 `curl -X POST -F 'files=@test.jpg' "http://localhost:/upload"`
 
-The detector also has a **SocketIO** upload endpoint that can be used to upload images and detections to the learning loop. The function receives a json dictionary, with the following entries:
-
-- `image`: the image data in jpg format
+The detector also has a **SocketIO** upload endpoint that can be used to upload images and detections to the learning loop. The function receives a dictionary, with the following entries:
 
+- `image`: the image data as dictionary with the following keys:
+  - `bytes`: bytes of the ndarray (retrieved via `ndarray.tobytes(order='C')`)
+  - `dtype`: data type of the ndarray as string (e.g. `uint8`, `float32`, etc.)
+  - `shape`: shape of the ndarray as tuple of ints (e.g. `(480, 640, 3)`)
 - `metadata`: a dictionary representing the image metadata. If metadata contains detections and/or annotations, UUIDs for the classes are automatically determined based on the category names. Metadata should follow the schema of the `ImageMetadata` data class.
-- `upload_priority`: boolean flag to prioritize the upload (defaults to False)
+- `upload_priority`: Optional boolean flag to prioritize the upload (defaults to False)
 
 The endpoint returns None if the upload was successful and an error message otherwise.
 

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/detector/detector_logic.py

@@ -2,6 +2,8 @@ import logging
 from abc import abstractmethod
 from typing import List, Optional
 
+import numpy as np
+
 from ..data_classes import ImageMetadata, ImagesMetadata, ModelInformation
 from ..globals import GLOBALS
 from .exceptions import NodeNeedsRestartError
@@ -43,7 +45,7 @@ class DetectorLogic():
         """Called when a (new) model was loaded. Initialize the model. Model information available via `self.model_info`"""
 
     @abstractmethod
-    def evaluate(self, image: bytes) -> ImageMetadata:  # pylint: disable=unused-argument
+    def evaluate(self, image: np.ndarray) -> ImageMetadata:
         """Evaluate the image and return the detections.
 
         Called by the detector node when an image should be evaluated (REST or SocketIO).
@@ -52,8 +54,9 @@ class DetectorLogic():
         The function should return empty metadata if the detector is not initialized."""
 
     @abstractmethod
-    def batch_evaluate(self, images: List[bytes]) -> ImagesMetadata:
+    def batch_evaluate(self, images: List[np.ndarray]) -> ImagesMetadata:
         """Evaluate a batch of images and return the detections.
+
         The resulting detections per image should be stored in the ImagesMetadata.
         Tags stored in the ImagesMetadata will be uploaded to the learning loop.
         The function should return empty metadata if the detector is not initialized."""

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/detector/detector_node.py

@@ -8,6 +8,8 @@ from dataclasses import asdict
 from datetime import datetime
 from typing import Dict, List, Optional
 
+import numpy as np
+
 try:
     from typing import Literal
 except ImportError:  # Python <= 3.8
@@ -33,6 +35,7 @@ from ..data_exchanger import DataExchanger, DownloadError
 from ..enums import OperationMode, VersionMode
 from ..globals import GLOBALS
 from ..helpers import background_tasks, environment_reader, run
+from ..helpers.misc import numpy_image_from_dict
 from ..node import Node
 from .detector_logic import DetectorLogic
 from .exceptions import NodeNeedsRestartError
@@ -225,9 +228,28 @@ class DetectorNode(Node):
 
         @self.sio.event
         async def detect(sid, data: Dict) -> Dict:
+            """Detect objects in a single image sent via SocketIO.
+
+            The data dict has the following schema:
+            - image: The image data as dictionary:
+              - bytes: bytes of the ndarray
+              - dtype: data type of the ndarray
+              - shape: shape of the ndarray
+            - camera_id: Optional camera ID
+            - tags: Optional list of tags
+            - source: Optional source string
+            - autoupload: Optional 'filtered', 'all' or 'disabled' (default: 'filtered')
+            - creation_date: Optional creation date in isoformat string
+            """
+            try:
+                image = numpy_image_from_dict(data['image'])
+            except Exception:
+                self.log.exception('could not parse image from socketio')
+                return {'error': 'could not parse image from data'}
+
             try:
                 det = await self.get_detections(
-                    raw_image=data['image'],
+                    image=image,
                     camera_id=data.get('camera_id', None),
                     tags=data.get('tags', []),
                     source=data.get('source', None),
@@ -246,9 +268,22 @@ class DetectorNode(Node):
 
         @self.sio.event
         async def batch_detect(sid, data: Dict) -> Dict:
+            """
+            Detect objects in a batch of images sent via SocketIO.
+
+            Data dict follows the schema of the detect endpoint, 
+            but 'images' is a list of image dicts.
+            """
+            try:
+                images_data = data['images']
+                images = [numpy_image_from_dict(image) for image in images_data]
+            except Exception:
+                self.log.exception('could not parse images from socketio')
+                return {'error': 'could not parse images from data'}
+
             try:
                 det = await self.get_batch_detections(
-                    raw_images=data['images'],
+                    images=images,
                     tags=data.get('tags', []),
                     camera_id=data.get('camera_id', None),
                     source=data.get('source', None),
@@ -304,8 +339,12 @@ class DetectorNode(Node):
             """Upload a single image with metadata to the learning loop.
 
             The data dict must contain:
-            - image: The image bytes to upload
+            - image: The image data as dictionary with the following keys:
+                - bytes: bytes of the ndarray (retrieved via `ndarray.tobytes(order='C')`)
+                - dtype: data type of the ndarray as string (e.g. `uint8`, `float32`, etc.)
+                - shape: shape of the ndarray as tuple of ints (e.g. `(480, 640, 3)`)
             - metadata: The metadata for the image (optional)
+            - upload_priority: Whether to upload with priority (optional)
             """
             self.log.debug('Processing upload via socketio.')
 
@@ -321,9 +360,15 @@ class DetectorNode(Node):
             else:
                 image_metadata = ImageMetadata()
 
+            try:
+                image = numpy_image_from_dict(data['image'])
+            except Exception:
+                self.log.exception('could not parse image from socketio')
+                return {'error': 'could not parse image from data'}
+
             try:
                 await self.upload_images(
-                    images=[data['image']],
+                    images=[image],
                     images_metadata=ImagesMetadata(items=[image_metadata]) if metadata else None,
                     upload_priority=data.get('upload_priority', False)
                 )
@@ -373,6 +418,7 @@ class DetectorNode(Node):
         )
 
         self.log_status_on_change(status.state, status)
+        response = None
 
         try:
             response = await self.loop_communicator.post(
@@ -380,8 +426,8 @@ class DetectorNode(Node):
         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))
+        if not response or not response.is_success:
+            self.log.warning('Status update failed. Response: "%s"', response)
 
     async def _update_model_if_required(self) -> None:
         """Check if a new model is available and update if necessary.
@@ -509,21 +555,24 @@ class DetectorNode(Node):
             self.log.error('could not reload app')
 
     async def get_detections(self,
-                             raw_image: bytes,
+                             image: np.ndarray,
                              tags: List[str],
                              *,
                              camera_id: Optional[str] = None,
                              source: Optional[str] = None,
                              autoupload: Literal['filtered', 'all', 'disabled'],
                              creation_date: Optional[str] = None) -> ImageMetadata:
-        """ Main processing function for the detector node when an image is received via REST or SocketIO.
-        This function infers the detections from the image, cares about uploading to the loop and returns the detections as ImageMetadata object.
-        Note: raw_image is a numpy array of type uint8, but not in the correct shape!
-        It can be converted e.g. using cv2.imdecode(np.frombuffer(image, np.uint8), cv2.IMREAD_COLOR)"""
+        """
+        Main processing function for the detector node.
+
+        Used when an image is received via REST or SocketIO.
+        This function infers the detections from the image, 
+        cares about uploading to the loop and returns the detections as ImageMetadata object.
+        """
 
         await self.detection_lock.acquire()
         try:
-            metadata = await run.io_bound(self.detector_logic.evaluate, raw_image)
+            metadata = await run.io_bound(self.detector_logic.evaluate, image)
         finally:
             self.detection_lock.release()
 
@@ -537,9 +586,9 @@ class DetectorNode(Node):
         self.log.debug('Detected: %d boxes, %d points, %d segs, %d classes', n_bo, n_po, n_se, n_cl)
 
         if autoupload == 'filtered':
-            background_tasks.create(self.relevance_filter.may_upload_detections(metadata, camera_id, raw_image))
+            background_tasks.create(self.relevance_filter.may_upload_detections(metadata, camera_id, image))
         elif autoupload == 'all':
-            background_tasks.create(self.outbox.save(raw_image, metadata))
+            background_tasks.create(self.outbox.save(image, metadata))
         elif autoupload == 'disabled':
             pass
         else:
@@ -547,19 +596,22 @@ class DetectorNode(Node):
         return metadata
 
     async def get_batch_detections(self,
-                                   raw_images: List[bytes],
+                                   images: List[np.ndarray],
                                    tags: List[str],
                                    *,
                                    camera_id: Optional[str] = None,
                                    source: Optional[str] = None,
                                    autoupload: str = 'filtered',
                                    creation_date: Optional[str] = None) -> ImagesMetadata:
-        """ Processing function for the detector node when a a batch inference is requested via SocketIO.
-        This function infers the detections from all images, cares about uploading to the loop and returns the detections as a list of ImageMetadata."""
+        """
+        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()
         try:
-            all_detections = await run.io_bound(self.detector_logic.batch_evaluate, raw_images)
+            all_detections = await run.io_bound(self.detector_logic.batch_evaluate, images)
         finally:
             self.detection_lock.release()
 
@@ -568,16 +620,16 @@ class DetectorNode(Node):
             metadata.source = source
             metadata.created = creation_date
 
-        for detections, raw_image in zip(all_detections.items, raw_images):
+        for detections, image in zip(all_detections.items, 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)
 
             if autoupload == 'filtered':
-                background_tasks.create(self.relevance_filter.may_upload_detections(detections, camera_id, raw_image))
+                background_tasks.create(self.relevance_filter.may_upload_detections(detections, camera_id, image))
             elif autoupload == 'all':
-                background_tasks.create(self.outbox.save(raw_image, detections))
+                background_tasks.create(self.outbox.save(image, detections))
             elif autoupload == 'disabled':
                 pass
             else:
@@ -586,7 +638,7 @@ class DetectorNode(Node):
 
     async def upload_images(
             self, *,
-            images: List[bytes],
+            images: List[np.ndarray],
             images_metadata: Optional[ImagesMetadata] = None,
             upload_priority: bool = False
     ) -> None:

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/detector/inbox_filter/cam_observation_history.py

@@ -1,8 +1,14 @@
 import os
 from typing import List, Union
 
-from ...data_classes import (BoxDetection, ClassificationDetection, ImageMetadata, Observation, PointDetection,
-                             SegmentationDetection)
+from ...data_classes import (
+    BoxDetection,
+    ClassificationDetection,
+    ImageMetadata,
+    Observation,
+    PointDetection,
+    SegmentationDetection,
+)
 
 
 class CamObservationHistory:
@@ -10,6 +16,8 @@ class CamObservationHistory:
         self.reset_time = 3600
         self.recent_observations: List[Observation] = []
         self.iou_threshold = 0.5
+        self.min_uncertain_threshold = float(os.environ.get('MIN_UNCERTAIN_THRESHOLD', '0.3'))
+        self.max_uncertain_threshold = float(os.environ.get('MAX_UNCERTAIN_THRESHOLD', '0.6'))
 
     def forget_old_detections(self) -> None:
         self.recent_observations = [detection
@@ -25,7 +33,8 @@ class CamObservationHistory:
                 continue
             if isinstance(detection, ClassificationDetection):
                 # self.recent_observations.append(Observation(detection))
-                causes.add('classification_detection')
+                if self.min_uncertain_threshold <= detection.confidence <= self.max_uncertain_threshold:
+                    causes.add('uncertain')
                 continue
 
             assert isinstance(detection, (BoxDetection, PointDetection)), f"Unknown detection type: {type(detection)}"
@@ -37,7 +46,7 @@ class CamObservationHistory:
                 continue
 
             self.recent_observations.append(Observation(detection))
-            if float(os.environ.get('MIN_UNCERTAIN_THRESHOLD', '0.3')) <= detection.confidence <= float(os.environ.get('MAX_UNCERTAIN_THRESHOLD', '0.6')):
+            if self.min_uncertain_threshold <= detection.confidence <= self.max_uncertain_threshold:
                 causes.add('uncertain')
 
         return list(causes)

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/detector/inbox_filter/relevance_filter.py

@@ -1,5 +1,7 @@
 from typing import Dict, List, Optional
 
+import numpy as np
+
 from ...data_classes.image_metadata import ImageMetadata
 from ..outbox import Outbox
 from .cam_observation_history import CamObservationHistory
@@ -15,7 +17,7 @@ class RelevanceFilter():
     async def may_upload_detections(self,
                                     image_metadata: ImageMetadata,
                                     cam_id: Optional[str],
-                                    raw_image: bytes) -> List[str]:
+                                    image: np.ndarray) -> List[str]:
         """Check if the detection should be uploaded to the outbox.
         If so, upload it and return the list of causes for the upload.
         """
@@ -34,5 +36,5 @@ class RelevanceFilter():
             causes.append('unexpected_observations_count')
         if len(causes) > 0:
             image_metadata.tags.extend(causes)
-            await self.outbox.save(raw_image, image_metadata)
+            await self.outbox.save(image, image_metadata)
         return causes

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/detector/outbox.py

@@ -16,6 +16,7 @@ from threading import Lock
 from typing import List, Optional, Tuple, TypeVar, Union
 
 import aiohttp
+import numpy as np
 import PIL
 import PIL.Image  # type: ignore
 from fastapi.encoders import jsonable_encoder
@@ -24,6 +25,7 @@ from ..data_classes import ImageMetadata
 from ..enums import OutboxMode
 from ..globals import GLOBALS
 from ..helpers import environment_reader, run
+from ..helpers.misc import numpy_array_to_jpg_bytes
 
 T = TypeVar('T')
 
@@ -76,13 +78,16 @@ class Outbox():
             self.upload_folders.append(file)
 
     async def save(self,
-                   image: bytes,
+                   image: np.ndarray,
                    image_metadata: Optional[ImageMetadata] = None,
                    upload_priority: bool = False) -> None:
+        """
+        Save an image and its metadata to disk. 
 
-        if not await run.io_bound(self._is_valid_jpg, image):
-            self.log.error('Invalid jpg image')
-            return
+        The data will be picked up by the continuous upload process.
+        """
+
+        jpg_bytes = numpy_array_to_jpg_bytes(image)
 
         if image_metadata is None:
             image_metadata = ImageMetadata()
@@ -90,7 +95,7 @@ class Outbox():
         identifier = datetime.now().isoformat(sep='_', timespec='microseconds')
 
         try:
-            await run.io_bound(self._save_files_to_disk, identifier, image, image_metadata, upload_priority)
+            await run.io_bound(self._save_files_to_disk, identifier, jpg_bytes, image_metadata, upload_priority)
         except Exception as e:
             self.log.error('Failed to save files for image %s: %s', identifier, e)
             return
@@ -104,7 +109,7 @@ class Outbox():
 
     def _save_files_to_disk(self,
                             identifier: str,
-                            image: bytes,
+                            jpeg_image: bytes,
                             image_metadata: ImageMetadata,
                             upload_priority: bool) -> None:
         subpath = 'priority' if upload_priority else 'normal'
@@ -119,7 +124,7 @@ class Outbox():
             json.dump(jsonable_encoder(asdict(image_metadata)), f)
 
         with open(tmp + f'/image_{identifier}.jpg', 'wb') as f:
-            f.write(image)
+            f.write(jpeg_image)
 
         if not os.path.exists(tmp):
             self.log.error('Could not rename %s to %s', tmp, full_path)

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/detector/rest/detect.py

@@ -9,6 +9,7 @@ except ImportError:  # Python <= 3.8
 from fastapi import APIRouter, File, Header, Request, UploadFile
 
 from ...data_classes.image_metadata import ImageMetadata
+from ...helpers.misc import jpg_bytes_to_numpy_array
 
 if TYPE_CHECKING:
     from ..detector_node import DetectorNode
@@ -35,23 +36,23 @@ async def http_detect(
     Multiple images example:
 
         for i in `seq 1 10`; do time curl --request POST -F 'file=@test.jpg' localhost:8004/detect; done
-
     """
+    node: 'DetectorNode' = request.app
+
     try:
         # Read file directly to bytes instead of using numpy
-        file_bytes = file.file.read()
+        file_bytes = await file.read()
     except Exception as exc:
         logging.exception('Error during reading of image %s.', file.filename)
         raise Exception(f'Uploaded file {file.filename} is no image file.') from exc
 
     try:
-        app: 'DetectorNode' = request.app
-        detections = await app.get_detections(raw_image=file_bytes,
-                                              camera_id=camera_id or None,
-                                              tags=tags.split(',') if tags else [],
-                                              source=source,
-                                              autoupload=autoupload or 'filtered',
-                                              creation_date=creation_date)
+        detections = await node.get_detections(image=jpg_bytes_to_numpy_array(file_bytes),
+                                               camera_id=camera_id or None,
+                                               tags=tags.split(',') if tags else [],
+                                               source=source,
+                                               autoupload=autoupload or 'filtered',
+                                               creation_date=creation_date)
     except Exception as exc:
         logging.exception('Error during detection of image %s.', file.filename)
         raise Exception(f'Error during detection of image {file.filename}.') from exc

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/detector/rest/upload.py

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

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/helpers/background_tasks.py

@@ -25,14 +25,14 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Awaitable, Dict, Set
+from typing import Coroutine, Dict, Set
 
 running_tasks: Set[asyncio.Task] = set()
 lazy_tasks_running: Dict[str, asyncio.Task] = {}
-lazy_tasks_waiting: Dict[str, Awaitable] = {}
+lazy_tasks_waiting: Dict[str, Coroutine] = {}
 
 
-def create(coroutine: Awaitable, *, name: str = 'unnamed task') -> asyncio.Task:
+def create(coroutine: Coroutine, *, name: str = 'unnamed task') -> asyncio.Task:
     """Wraps a loop.create_task call and ensures there is an exception handler added to the task.
 
     If the task raises an exception, it is logged and handled by the global exception handlers.
@@ -48,7 +48,7 @@ def create(coroutine: Awaitable, *, name: str = 'unnamed task') -> asyncio.Task:
     return task
 
 
-def create_lazy(coroutine: Awaitable, *, name: str) -> None:
+def create_lazy(coroutine: Coroutine, *, name: str) -> None:
     """Wraps a create call and ensures a second task with the same name is delayed until the first one is done.
 
     If a third task with the same name is created while the first one is still running, the second one is discarded.

{learning_loop_node-0.17.1 → learning_loop_node-0.18.0}/learning_loop_node/helpers/misc.py

@@ -1,6 +1,7 @@
 """original copied from https://quantlane.com/blog/ensure-asyncio-task-exceptions-get-logged/"""
 import asyncio
 import functools
+import io
 import json
 import logging
 import os
@@ -9,10 +10,12 @@ import sys
 from dataclasses import asdict
 from glob import glob
 from time import perf_counter
-from typing import Any, Coroutine, List, Optional, Tuple, TypeVar
+from typing import Any, Coroutine, Dict, List, Optional, Tuple, TypeVar
 from uuid import UUID, uuid4
 
+import numpy as np
 import pynvml
+from PIL import Image
 
 from ..data_classes.general import Context
 from ..data_classes.socket_response import SocketResponse
@@ -204,3 +207,33 @@ def create_training_folder(project_folder: str, trainings_id: str) -> str:
     training_folder = f'{project_folder}/trainings/{trainings_id}'
     os.makedirs(training_folder, exist_ok=True)
     return training_folder
+
+
+def jpg_bytes_to_numpy_array(jpg_bytes: bytes) -> np.ndarray:
+    """Convert jpg bytes to numpy array."""
+    image = Image.open(io.BytesIO(jpg_bytes))
+    return np.array(image)
+
+
+def numpy_array_to_jpg_bytes(image_array: np.ndarray) -> bytes:
+    """Convert jpg bytes to numpy array."""
+    buffer = io.BytesIO()
+    Image.fromarray(image_array).save(buffer, format="JPEG")
+    jpg_bytes = buffer.getvalue()
+    return jpg_bytes
+
+
+def numpy_image_from_dict(image_data: Dict) -> np.ndarray:
+    """
+    Convert image dict to numpy array.
+
+    The image_data dict should have the following keys:
+    - bytes: bytes of the image in C order (row-major)
+    - dtype: data type of the pixel values
+    - shape: shape of the image (height, width, channels)
+    """
+
+    image_bytes = image_data['bytes']
+    image_dtype = image_data['dtype']
+    image_shape = image_data['shape']
+    return np.frombuffer(image_bytes, dtype=image_dtype).reshape(image_shape, order='C')