learning-loop-node 0.10.7__py3-none-any.whl → 0.10.9__py3-none-any.whl

learning_loop_node/detector/detector_node.py

@@ -99,7 +99,7 @@ class DetectorNode(Node):
 
     async def on_shutdown(self) -> None:
         try:
-            self.outbox.ensure_continuous_upload_stopped()
+            await self.outbox.ensure_continuous_upload_stopped()
             for sid in self.connected_clients:
                 # pylint: disable=no-member
                 await self.sio.disconnect(sid)  # type:ignore

learning_loop_node/detector/outbox.py

@@ -1,8 +1,10 @@
+import asyncio
+import io
 import json
 import logging
 import os
 import shutil
-import time
+from asyncio import Task
 from dataclasses import asdict
 from datetime import datetime
 from enum import Enum
@@ -10,9 +12,10 @@ from glob import glob
 from io import BufferedReader, TextIOWrapper
 from multiprocessing import Event
 from multiprocessing.synchronize import Event as SyncEvent
-from threading import Thread
-from typing import List, Optional
+from typing import List, Optional, Tuple, Union
 
+import PIL
+import PIL.Image  # type: ignore
 import requests
 from fastapi.encoders import jsonable_encoder
 
@@ -29,6 +32,7 @@ class OutboxMode(Enum):
 class Outbox():
     def __init__(self) -> None:
         self.log = logging.getLogger()
+        self.log.setLevel(logging.DEBUG)
         self.path = f'{GLOBALS.data_folder}/outbox'
         os.makedirs(self.path, exist_ok=True)
 
@@ -47,9 +51,15 @@ class Outbox():
         self.UPLOAD_TIMEOUT_S = 30
 
         self.shutdown_event: SyncEvent = Event()
-        self.upload_process: Optional[Thread] = None
+        self.upload_task: Optional[Task] = None
+
+        self.upload_counter = 0
 
     def save(self, image: bytes, detections: Optional[Detections] = None, tags: Optional[List[str]] = None) -> None:
+        if not self._is_valid_jpg(image):
+            self.log.error('Invalid jpg image')
+            return
+
         if detections is None:
             detections = Detections()
         if not tags:
@@ -81,42 +91,57 @@ class Outbox():
             return
 
         self.shutdown_event.clear()
-        self.upload_process = Thread(target=self._continuous_upload, name='OutboxUpload')
-        self.upload_process.start()
+        self.upload_task = asyncio.create_task(self._continuous_upload())
 
-    def _continuous_upload(self):
+    async def _continuous_upload(self):
         self.log.info('continuous upload started')
         assert self.shutdown_event is not None
         while not self.shutdown_event.is_set():
             self.upload()
-            time.sleep(5)
+            await asyncio.sleep(5)
         self.log.info('continuous upload ended')
 
     def upload(self):
         items = self.get_data_files()
-        if items:
-            self.log.info('Found %s images to upload', len(items))
-            for i in range(0, len(items), self.BATCH_SIZE):
-                batch_items = items[i:i+self.BATCH_SIZE]
-                if self.shutdown_event.is_set():
-                    break
-                try:
-                    self._upload_batch(batch_items)
-                except Exception:
-                    self.log.exception('Could not upload files')
-        else:
-            self.log.info('No images found to upload')
+        if not items:
+            self.log.debug('No images found to upload')
+            return
+
+        self.log.info('Found %s images to upload', len(items))
+        for i in range(0, len(items), self.BATCH_SIZE):
+            batch_items = items[i:i+self.BATCH_SIZE]
+            if self.shutdown_event.is_set():
+                break
+            try:
+                self._upload_batch(batch_items)
+            except Exception:
+                self.log.exception('Could not upload files')
 
     def _upload_batch(self, items: List[str]):
-        data: List[tuple[str, TextIOWrapper | BufferedReader]] = []
+
+        # NOTE: keys are not relevant for the server, but using a fixed key like 'files'
+        # results in a post failure on the first run of the test in a docker environment (WTF)
+
+        data: List[Tuple[str, Union[TextIOWrapper, BufferedReader]]] = []
         data = [('files', open(f'{item}/image.json', 'r')) for item in items]
         data += [('files', open(f'{item}/image.jpg', 'rb')) for item in items]
 
-        response = requests.post(self.target_uri, files=data, timeout=self.UPLOAD_TIMEOUT_S)
+        try:
+            response = requests.post(self.target_uri, files=data, timeout=self.UPLOAD_TIMEOUT_S)
+        except Exception:
+            self.log.exception('Could not upload images')
+            return
+        finally:
+            self.log.info('Closing files')
+            for _, file in data:
+                file.close()
+
         if response.status_code == 200:
+            self.upload_counter += len(items)
             for item in items:
                 shutil.rmtree(item, ignore_errors=True)
             self.log.info('Uploaded %s images successfully', len(items))
+
         elif response.status_code == 422:
             if len(items) == 1:
                 self.log.error('Broken content in image: %s\n Skipping.', items[0])
@@ -129,36 +154,43 @@ class Outbox():
         else:
             self.log.error('Could not upload images: %s', response.content)
 
-    def ensure_continuous_upload_stopped(self) -> bool:
+    def _is_valid_jpg(self, image: bytes) -> bool:
+        try:
+            _ = PIL.Image.open(io.BytesIO(image), formats=['JPEG'])
+            return True
+        except Exception:
+            self.log.exception('Invalid jpg image')
+            return False
+
+    async def ensure_continuous_upload_stopped(self) -> bool:
         self.log.debug('Outbox: Ensuring continuous upload')
         if not self._upload_process_alive():
             self.log.debug('Upload thread already stopped')
             return True
-        proc = self.upload_process
-        if not proc:
+
+        if not self.upload_task:
             return True
 
         try:
             assert self.shutdown_event is not None
             self.shutdown_event.set()
-            assert proc is not None
-            proc.join(self.UPLOAD_TIMEOUT_S + 1)
+            await asyncio.wait_for(self.upload_task, timeout=self.UPLOAD_TIMEOUT_S + 1)
+        except asyncio.TimeoutError:
+            self.log.error('Upload task did not terminate in time')
+            return False
         except Exception:
-            self.log.exception('Error while shutting down upload thread: ')
-
-        if proc.is_alive():
-            self.log.error('Upload thread did not terminate')
+            self.log.exception('Error while shutting down upload task: ')
             return False
 
         self.log.info('Upload thread terminated')
         return True
 
     def _upload_process_alive(self) -> bool:
-        return bool(self.upload_process and self.upload_process.is_alive())
+        return bool(self.upload_task and not self.upload_task.done())
 
     def get_mode(self) -> OutboxMode:
         ''':return: current mode ('continuous_upload' or 'stopped')'''
-        if self.upload_process and self.upload_process.is_alive():
+        if self._upload_process_alive():
             current_mode = OutboxMode.CONTINUOUS_UPLOAD
         else:
             current_mode = OutboxMode.STOPPED
@@ -166,7 +198,7 @@ class Outbox():
         self.log.debug('Outbox: Current mode is %s', current_mode)
         return current_mode
 
-    def set_mode(self, mode: OutboxMode | str):
+    async def set_mode(self, mode: Union[OutboxMode, str]) -> None:
         ''':param mode: 'continuous_upload' or 'stopped'
         :raises ValueError: if mode is not a valid OutboxMode
         :raises TimeoutError: if the upload thread does not terminate within 31 seconds with mode='stopped'
@@ -178,7 +210,7 @@ class Outbox():
             self.ensure_continuous_upload()
         elif mode == OutboxMode.STOPPED:
             try:
-                self.ensure_continuous_upload_stopped()
+                await self.ensure_continuous_upload_stopped()
             except TimeoutError as e:
                 raise TimeoutError(f'Upload thread did not terminate within {self.UPLOAD_TIMEOUT_S} seconds.') from e
 

learning_loop_node/detector/rest/outbox_mode.py

@@ -26,7 +26,7 @@ async def put_outbox_mode(request: Request):
     outbox: Outbox = request.app.outbox
     content = str(await request.body(), 'utf-8')
     try:
-        outbox.set_mode(content)
+        await outbox.set_mode(content)
     except TimeoutError as e:
         raise HTTPException(202, 'Setting has not completed, yet: ' + str(e)) from e
     except ValueError as e:

learning_loop_node/tests/annotator/conftest.py

@@ -0,0 +1,50 @@
+import asyncio
+import logging
+import os
+import shutil
+
+import pytest
+
+from ...globals import GLOBALS
+from ...loop_communication import LoopCommunicator
+
+# ====================================== REDUNDANT FIXTURES IN ALL CONFTESTS ! ======================================
+
+
+@pytest.fixture()
+async def setup_test_project():  # pylint: disable=redefined-outer-name
+    loop_communicator = LoopCommunicator()
+    await loop_communicator.delete("/zauberzeug/projects/pytest_nodelib_annotator?keep_images=true")
+    await asyncio.sleep(1)
+    project_conf = {
+        'project_name': 'pytest_nodelib_annotator', 'inbox': 0, 'annotate': 0, 'review': 0, 'complete': 3, 'image_style': 'beautiful',
+        'box_categories': 2, 'point_categories': 2, 'segmentation_categories': 2, 'thumbs': False, 'tags': 0,
+        'trainings': 1, 'box_detections': 3, 'box_annotations': 0}
+    assert (await loop_communicator.post("/zauberzeug/projects/generator", json=project_conf)).status_code == 200
+    yield
+    await loop_communicator.delete("/zauberzeug/projects/pytest_nodelib_annotator?keep_images=true")
+    await loop_communicator.shutdown()
+
+
+@pytest.fixture(autouse=True, scope='session')
+def clear_loggers():
+    """Remove handlers from all loggers"""
+    # see https://github.com/pytest-dev/pytest/issues/5502
+    yield
+
+    loggers = [logging.getLogger()] + list(logging.Logger.manager.loggerDict.values())
+    for logger in loggers:
+        if not isinstance(logger, logging.Logger):
+            continue
+        handlers = getattr(logger, 'handlers', [])
+        for handler in handlers:
+            logger.removeHandler(handler)
+
+
+@pytest.fixture(autouse=True, scope='function')
+def data_folder():
+    GLOBALS.data_folder = '/tmp/learning_loop_lib_data'
+    shutil.rmtree(GLOBALS.data_folder, ignore_errors=True)
+    os.makedirs(GLOBALS.data_folder, exist_ok=True)
+    yield
+    shutil.rmtree(GLOBALS.data_folder, ignore_errors=True)

learning_loop_node/{annotation/tests → tests/annotator}/test_annotator_node.py

@@ -1,4 +1,3 @@
-import asyncio
 import os
 from dataclasses import asdict
 from typing import Dict
@@ -6,10 +5,10 @@ from typing import Dict
 import pytest
 from fastapi.encoders import jsonable_encoder
 
-from learning_loop_node.annotation.annotator_logic import AnnotatorLogic
-from learning_loop_node.annotation.annotator_node import AnnotatorNode
-from learning_loop_node.data_classes import (AnnotationData, AnnotationEventType, Category, CategoryType, Context,
-                                             Point, ToolOutput, UserInput)
+from ...annotation.annotator_logic import AnnotatorLogic
+from ...annotation.annotator_node import AnnotatorNode
+from ...data_classes import (AnnotationData, AnnotationEventType, Category, CategoryType, Context, Point, ToolOutput,
+                             UserInput)
 
 
 class MockedAnnotatatorLogic(AnnotatorLogic):
@@ -27,8 +26,8 @@ def default_user_input() -> UserInput:
     annotation_data = AnnotationData(
         coordinate=Point(x=0, y=0),
         event_type=AnnotationEventType.LeftMouseDown,
-        context=Context(organization='zauberzeug', project='pytest_p'),
-        image_uuid='f786350c-89ca-9424-9b00-720a9a85fe09',
+        context=Context(organization='zauberzeug', project='pytest_nodelib_annotator'),
+        image_uuid='10f7d7d2-4076-7006-af37-fa28a6a848ae',
         category=Category(id='some_id', name='category_1', description='',
                           hotkey='', color='', type=CategoryType.Segmentation)
     )
@@ -39,13 +38,12 @@ def default_user_input() -> UserInput:
 
 @pytest.mark.asyncio
 async def test_image_download(setup_test_project):  # pylint: disable=unused-argument
-    # TODO: This test depends on a pseudo-random uuid..
-    image_path = '/tmp/learning_loop_lib_data/zauberzeug/pytest_p/images/f786350c-89ca-9424-9b00-720a9a85fe09.jpg'
+    image_folder = '/tmp/learning_loop_lib_data/zauberzeug/pytest_nodelib_annotator/images'
 
-    assert os.path.exists(image_path) is False
+    assert os.path.exists(image_folder) is False or len(os.listdir(image_folder)) == 0
 
     node = AnnotatorNode(name="", uuid="", annotator_logic=MockedAnnotatatorLogic())
     user_input = default_user_input()
     _ = await node._handle_user_input(jsonable_encoder(asdict(user_input)))  # pylint: disable=protected-access
 
-    assert os.path.exists(image_path) is True
+    assert os.path.exists(image_folder) is True and len(os.listdir(image_folder)) == 1

learning_loop_node/{detector/tests → tests/detector}/conftest.py

@@ -1,3 +1,4 @@
+import shutil
 import asyncio
 import logging
 import multiprocessing
@@ -11,10 +12,9 @@ import pytest
 import socketio
 import uvicorn
 
-from learning_loop_node import DetectorNode
-from learning_loop_node.detector.outbox import Outbox
-from learning_loop_node.globals import GLOBALS
-
+from ...detector.detector_node import DetectorNode
+from ...detector.outbox import Outbox
+from ...globals import GLOBALS
 from .testing_detector import TestingDetectorLogic
 
 logging.basicConfig(level=logging.INFO)
@@ -112,3 +112,29 @@ async def sio_client() -> AsyncGenerator[socketio.AsyncClient, None]:
 def get_outbox_files(outbox: Outbox):
     files = glob(f'{outbox.path}/**/*', recursive=True)
     return [file for file in files if os.path.isfile(file)]
+
+# ====================================== REDUNDANT FIXTURES IN ALL CONFTESTS ! ======================================
+
+
+@pytest.fixture(autouse=True, scope='session')
+def clear_loggers():
+    """Remove handlers from all loggers"""
+    # see https://github.com/pytest-dev/pytest/issues/5502
+    yield
+
+    loggers = [logging.getLogger()] + list(logging.Logger.manager.loggerDict.values())
+    for logger in loggers:
+        if not isinstance(logger, logging.Logger):
+            continue
+        handlers = getattr(logger, 'handlers', [])
+        for handler in handlers:
+            logger.removeHandler(handler)
+
+
+@pytest.fixture(autouse=True, scope='function')
+def data_folder():
+    GLOBALS.data_folder = '/tmp/learning_loop_lib_data'
+    shutil.rmtree(GLOBALS.data_folder, ignore_errors=True)
+    os.makedirs(GLOBALS.data_folder, exist_ok=True)
+    yield
+    shutil.rmtree(GLOBALS.data_folder, ignore_errors=True)

learning_loop_node/{detector/inbox_filter/tests → tests/detector/inbox_filter}/test_observation.py

@@ -1,7 +1,7 @@
 import time
 from datetime import datetime, timedelta
 
-from learning_loop_node.data_classes import BoxDetection, Observation
+from ....data_classes import BoxDetection, Observation
 
 
 def test_aging():

learning_loop_node/{detector/inbox_filter/tests → tests/detector/inbox_filter}/test_relevance_group.py

@@ -5,13 +5,8 @@ from typing import List
 
 from dacite import from_dict
 
-from learning_loop_node.data_classes.detections import (BoxDetection,
-                                                        Detections, Point,
-                                                        PointDetection,
-                                                        SegmentationDetection,
-                                                        Shape)
-from learning_loop_node.detector.inbox_filter.cam_observation_history import \
-    CamObservationHistory
+from ....data_classes.detections import BoxDetection, Detections, Point, PointDetection, SegmentationDetection, Shape
+from ....detector.inbox_filter.cam_observation_history import CamObservationHistory
 
 dirt_detection = BoxDetection(category_name='dirt', x=0, y=0, width=100, height=100,
                               category_id='xyz', model_name='test_model', confidence=.3)

learning_loop_node/{detector/inbox_filter/tests → tests/detector/inbox_filter}/test_unexpected_observations_count.py

@@ -3,12 +3,9 @@ from typing import List
 
 import pytest
 
-from learning_loop_node.data_classes.detections import (BoxDetection,
-                                                        Detections,
-                                                        PointDetection)
-from learning_loop_node.detector.inbox_filter.relevance_filter import \
-    RelevanceFilter
-from learning_loop_node.detector.outbox import Outbox
+from ....data_classes.detections import BoxDetection, Detections, PointDetection
+from ....detector.inbox_filter.relevance_filter import RelevanceFilter
+from ....detector.outbox import Outbox
 
 h_conf_box_det = BoxDetection(category_name='dirt', x=0, y=0, width=100,
                               height=100, category_id='xyz', confidence=.9, model_name='test_model',)

learning_loop_node/tests/detector/pytest.ini

@@ -0,0 +1,10 @@
+[pytest]
+python_files = test_*.py
+asyncio_mode = auto
+
+cache_dir = /tmp/pytest_cache 
+    
+# for debbuging tests:
+; log_cli_level = INFO
+; log_cli_format = %(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)
+; log_cli_date_format=%Y-%m-%d %H:%M:%S

learning_loop_node/{detector/tests → tests/detector}/test_client_communication.py

@@ -1,16 +1,19 @@
 import asyncio
 import json
+import os
 
 import pytest
 import requests
 
-from learning_loop_node import DetectorNode
-from learning_loop_node.data_classes import ModelInformation
-from learning_loop_node.detector.tests.conftest import get_outbox_files
-from learning_loop_node.globals import GLOBALS
-
+from ...data_classes import ModelInformation
+from ...detector.detector_node import DetectorNode
+from ...globals import GLOBALS
+from .conftest import get_outbox_files
 from .testing_detector import TestingDetectorLogic
 
+file_path = os.path.abspath(__file__)
+test_image_path = os.path.join(os.path.dirname(file_path), 'test.jpg')
+
 
 @pytest.mark.asyncio
 async def test_detector_path(test_detector_node: DetectorNode):
@@ -20,7 +23,7 @@ async def test_detector_path(test_detector_node: DetectorNode):
 
 
 async def test_sio_detect(test_detector_node, sio_client):
-    with open('detector/tests/test.jpg', 'rb') as f:
+    with open(test_image_path, 'rb') as f:
         image_bytes = f.read()
 
     await asyncio.sleep(5)
@@ -44,7 +47,7 @@ async def test_sio_detect(test_detector_node, sio_client):
 
 @pytest.mark.parametrize('grouping_key', ['mac', 'camera_id'])
 def test_rest_detect(test_detector_node: DetectorNode, grouping_key: str):
-    image = {('file', open('detector/tests/test.jpg', 'rb'))}
+    image = {('file', open(test_image_path, 'rb'))}
     headers = {grouping_key: '0:0:0:0', 'tags':  'some_tag'}
 
     assert isinstance(test_detector_node.detector_logic, TestingDetectorLogic)
@@ -71,7 +74,7 @@ def test_rest_detect(test_detector_node: DetectorNode, grouping_key: str):
 def test_rest_upload(test_detector_node: DetectorNode):
     assert len(get_outbox_files(test_detector_node.outbox)) == 0
 
-    image = {('files', open('detector/tests/test.jpg', 'rb'))}
+    image = {('files', open(test_image_path, 'rb'))}
     response = requests.post(f'http://localhost:{GLOBALS.detector_port}/upload', files=image, timeout=30)
     assert response.status_code == 200
     assert len(get_outbox_files(test_detector_node.outbox)) == 2, 'There should be one image and one .json file.'
@@ -81,7 +84,7 @@ def test_rest_upload(test_detector_node: DetectorNode):
 async def test_sio_upload(test_detector_node: DetectorNode, sio_client):
     assert len(get_outbox_files(test_detector_node.outbox)) == 0
 
-    with open('detector/tests/test.jpg', 'rb') as f:
+    with open(test_image_path, 'rb') as f:
         image_bytes = f.read()
     result = await sio_client.call('upload', {'image': image_bytes})
     assert result is None

learning_loop_node/tests/detector/test_outbox.py

@@ -0,0 +1,96 @@
+import asyncio
+import io
+import os
+import shutil
+
+import pytest
+from PIL import Image
+
+from ...data_classes import Detections
+from ...detector.detector_node import DetectorNode
+from ...detector.outbox import Outbox
+from ...globals import GLOBALS
+
+# pylint: disable=redefined-outer-name
+
+
+@pytest.fixture()
+async def test_outbox():
+    os.environ['LOOP_ORGANIZATION'] = 'zauberzeug'
+    os.environ['LOOP_PROJECT'] = 'demo'
+    shutil.rmtree(f'{GLOBALS.data_folder}/outbox', ignore_errors=True)
+    test_outbox = Outbox()
+
+    yield test_outbox
+    await test_outbox.set_mode('stopped')
+    shutil.rmtree(test_outbox.path, ignore_errors=True)
+
+
+@pytest.mark.asyncio
+async def test_files_are_automatically_uploaded_by_node(test_detector_node: DetectorNode):
+    test_detector_node.outbox.save(get_test_image_binary(), Detections())
+    assert await wait_for_outbox_count(test_detector_node.outbox, 1)
+    assert await wait_for_outbox_count(test_detector_node.outbox, 0)
+
+
+@pytest.mark.asyncio
+async def test_set_outbox_mode(test_outbox: Outbox):
+    await test_outbox.set_mode('stopped')
+    test_outbox.save(get_test_image_binary())
+    assert await wait_for_outbox_count(test_outbox, 1)
+    await asyncio.sleep(6)
+    assert await wait_for_outbox_count(test_outbox, 1), 'File was cleared even though outbox should be stopped'
+
+    await test_outbox.set_mode('continuous_upload')
+    assert await wait_for_outbox_count(test_outbox, 0), 'File was not cleared even though outbox should be in continuous_upload'
+    assert test_outbox.upload_counter == 1
+
+
+@pytest.mark.asyncio
+async def test_outbox_upload_is_successful(test_outbox: Outbox):
+    test_outbox.save(get_test_image_binary())
+    await asyncio.sleep(1)
+    test_outbox.save(get_test_image_binary())
+    assert await wait_for_outbox_count(test_outbox, 2)
+    test_outbox.upload()
+    assert await wait_for_outbox_count(test_outbox, 0)
+    assert test_outbox.upload_counter == 2
+
+
+@pytest.mark.asyncio
+async def test_invalid_jpg_is_not_saved(test_outbox: Outbox):
+    invalid_bytes = b'invalid jpg'
+    test_outbox.save(invalid_bytes)
+    assert len(test_outbox.get_data_files()) == 0
+
+
+# ------------------------------ Helper functions --------------------------------------
+
+
+def get_test_image_binary():
+    img = Image.new('RGB', (60, 30), color=(73, 109, 137))
+    # convert img to jpg binary
+
+    img_byte_arr = io.BytesIO()
+    img.save(img_byte_arr, format='JPEG')
+    img_byte_arr = img_byte_arr.getvalue()
+    return img_byte_arr
+
+    # return img.tobytes() # NOT WORKING
+
+    # img.save('/tmp/image.jpg')
+    # with open('/tmp/image.jpg', 'rb') as f:
+    #     data = f.read()
+
+    # return data
+
+    # img = np.ones((300, 300, 3), np.uint8)*255 # NOT WORKING
+    # return img.tobytes()
+
+
+async def wait_for_outbox_count(outbox: Outbox, count: int, timeout: int = 10) -> bool:
+    for _ in range(timeout):
+        if len(outbox.get_data_files()) == count:
+            return True
+        await asyncio.sleep(1)
+    return False

learning_loop_node/{detector/tests → tests/detector}/test_relevance_filter.py

@@ -1,15 +1,17 @@
 import asyncio
+import os
 
 import numpy as np
 import pytest
 
-from learning_loop_node import DetectorNode
-from learning_loop_node.data_classes import (BoxDetection, Detections,
-                                             PointDetection)
-
+from ...data_classes import BoxDetection, Detections, PointDetection
+from ...detector.detector_node import DetectorNode
 from .conftest import get_outbox_files
 from .testing_detector import TestingDetectorLogic
 
+file_path = os.path.abspath(__file__)
+test_image_path = os.path.join(os.path.dirname(file_path), 'test.jpg')
+
 
 @pytest.mark.parametrize('autoupload, expected_file_count', [(None, 2), ('all', 4)])
 async def test_filter_is_used_by_node(test_detector_node: DetectorNode, autoupload, expected_file_count):
@@ -28,11 +30,11 @@ async def test_filter_is_used_by_node(test_detector_node: DetectorNode, autouplo
     assert test_detector_node.outbox.path.startswith('/tmp')
     assert len(get_outbox_files(test_detector_node.outbox)) == 0
 
-    image = np.fromfile('detector/tests/test.jpg', np.uint8)
+    image = np.fromfile(file=test_image_path, dtype=np.uint8)
     _ = await test_detector_node.get_detections(image, '00:.....', tags=[], autoupload=autoupload)
     # NOTE adding second images with identical detections
     _ = await test_detector_node.get_detections(image, '00:.....', tags=[], autoupload=autoupload)
     await asyncio.sleep(.5)  # files are stored asynchronously
 
-    assert len(get_outbox_files(test_detector_node.outbox)) == expected_file_count,\
+    assert len(get_outbox_files(test_detector_node.outbox)) == expected_file_count, \
         'There should be 1 image and 1 .json file for every detection in the outbox'

learning_loop_node/{detector/tests → tests/detector}/testing_detector.py

@@ -2,9 +2,9 @@ import logging
 
 import numpy as np
 
-from learning_loop_node import DetectorLogic
-from learning_loop_node.conftest import get_dummy_detections
-from learning_loop_node.data_classes import Detections
+from ...data_classes import Detections
+from ...detector.detector_logic import DetectorLogic
+from ..test_helper import get_dummy_detections
 
 
 class TestingDetectorLogic(DetectorLogic):