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

learning_loop_node/tests/detector/conftest.py

@@ -12,6 +12,9 @@ import pytest
 import socketio
 import uvicorn
 
+from learning_loop_node.data_classes import BoxDetection, Detections
+from learning_loop_node.detector.detector_logic import DetectorLogic
+
 from ...detector.detector_node import DetectorNode
 from ...detector.outbox import Outbox
 from ...globals import GLOBALS
@@ -38,8 +41,8 @@ def should_have_segmentations(request) -> bool:
 async def test_detector_node():
     """Initializes and runs a detector testnode. Note that the running instance and the one the function returns are not the same instances!"""
 
-    os.environ['ORGANIZATION'] = 'zauberzeug'
-    os.environ['PROJECT'] = 'demo'
+    os.environ['LOOP_ORGANIZATION'] = 'zauberzeug'
+    os.environ['LOOP_PROJECT'] = 'demo'
 
     detector = TestingDetectorLogic()
     node = DetectorNode(name='test', detector=detector)
@@ -113,6 +116,37 @@ def get_outbox_files(outbox: Outbox):
     files = glob(f'{outbox.path}/**/*', recursive=True)
     return [file for file in files if os.path.isfile(file)]
 
+
+@pytest.fixture
+def mock_detector_logic():
+    class MockDetectorLogic(DetectorLogic):  # pylint: disable=abstract-method
+        def __init__(self):
+            super().__init__('mock')
+            self.detections = Detections(
+                box_detections=[BoxDetection(category_name="test",
+                                             category_id="1",
+                                             confidence=0.9,
+                                             x=0, y=0, width=10, height=10,
+                                             model_name="mock",
+                                             )]
+            )
+
+        @property
+        def is_initialized(self):
+            return True
+
+        def evaluate_with_all_info(self, image, tags, source):  # pylint: disable=signature-differs
+            return self.detections
+
+    return MockDetectorLogic()
+
+
+@pytest.fixture
+def detector_node(mock_detector_logic):
+    os.environ['LOOP_ORGANIZATION'] = 'test_organization'
+    os.environ['LOOP_PROJECT'] = 'test_project'
+    return DetectorNode(name="test_node", detector=mock_detector_logic)
+
 # ====================================== REDUNDANT FIXTURES IN ALL CONFTESTS ! ======================================
 
 

learning_loop_node/tests/detector/test_client_communication.py

@@ -93,10 +93,10 @@ async def test_sio_upload(test_detector_node: DetectorNode, sio_client):
 
 # NOTE: This test seems to be flaky.
 async def test_about_endpoint(test_detector_node: DetectorNode):
-    await asyncio.sleep(3)
+    await asyncio.sleep(11)
     response = requests.get(f'http://localhost:{GLOBALS.detector_port}/about', timeout=30)
 
-    assert response.status_code == 200
+    assert response.status_code == 200, response.content
     response_dict = json.loads(response.content)
     assert response_dict['model_info']
     model_information = ModelInformation.from_dict(response_dict['model_info'])
@@ -108,59 +108,60 @@ async def test_about_endpoint(test_detector_node: DetectorNode):
 
 
 async def test_model_version_api(test_detector_node: DetectorNode):
-    await asyncio.sleep(3)
+    await asyncio.sleep(11)
 
     response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200
+    assert response.status_code == 200, response.content
     response_dict = json.loads(response.content)
+    assert response_dict['version_control'] == 'follow_loop'
     assert response_dict['current_version'] == '1.1'
     assert response_dict['target_version'] == '1.1'
     assert response_dict['loop_version'] == '1.1'
     assert response_dict['local_versions'] == ['1.1']
-    assert response_dict['version_control'] == 'follow_loop'
 
     response = requests.put(f'http://localhost:{GLOBALS.detector_port}/model_version', data='1.0', timeout=30)
+    assert response.status_code == 200, response.content
     response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200
+    assert response.status_code == 200, response.content
     response_dict = json.loads(response.content)
+    assert response_dict['version_control'] == 'specific_version'
     assert response_dict['current_version'] == '1.1'
     assert response_dict['target_version'] == '1.0'
     assert response_dict['loop_version'] == '1.1'
     assert response_dict['local_versions'] == ['1.1']
-    assert response_dict['version_control'] == 'specific_version'
 
     await asyncio.sleep(11)
-
     response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200
+    assert response.status_code == 200, response.content
     response_dict = json.loads(response.content)
+    assert response_dict['version_control'] == 'specific_version'
     assert response_dict['current_version'] == '1.0'
     assert response_dict['target_version'] == '1.0'
     assert response_dict['loop_version'] == '1.1'
     assert set(response_dict['local_versions']) == set(['1.1', '1.0'])
-    assert response_dict['version_control'] == 'specific_version'
 
     response = requests.put(f'http://localhost:{GLOBALS.detector_port}/model_version', data='pause', timeout=30)
+    assert response.status_code == 200, response.content
     await asyncio.sleep(11)
     response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200
+    assert response.status_code == 200, response.content
     response_dict = json.loads(response.content)
+    assert response_dict['version_control'] == 'pause'
     assert response_dict['current_version'] == '1.0'
     assert response_dict['target_version'] == '1.0'
     assert response_dict['loop_version'] == '1.1'
     assert set(response_dict['local_versions']) == set(['1.1', '1.0'])
-    assert response_dict['version_control'] == 'pause'
 
     response = requests.put(f'http://localhost:{GLOBALS.detector_port}/model_version', data='follow_loop', timeout=30)
     await asyncio.sleep(11)
     response = requests.get(f'http://localhost:{GLOBALS.detector_port}/model_version', timeout=30)
-    assert response.status_code == 200
+    assert response.status_code == 200, response.content
     response_dict = json.loads(response.content)
+    assert response_dict['version_control'] == 'follow_loop'
     assert response_dict['current_version'] == '1.1'
     assert response_dict['target_version'] == '1.1'
     assert response_dict['loop_version'] == '1.1'
     assert set(response_dict['local_versions']) == set(['1.1', '1.0'])
-    assert response_dict['version_control'] == 'follow_loop'
 
 
 async def test_rest_outbox_mode(test_detector_node: DetectorNode):
@@ -169,9 +170,9 @@ async def test_rest_outbox_mode(test_detector_node: DetectorNode):
     def check_switch_to_mode(mode: str):
         response = requests.put(f'http://localhost:{GLOBALS.detector_port}/outbox_mode',
                                 data=mode, timeout=30)
-        assert response.status_code == 200
+        assert response.status_code == 200, response.content
         response = requests.get(f'http://localhost:{GLOBALS.detector_port}/outbox_mode', timeout=30)
-        assert response.status_code == 200
+        assert response.status_code == 200, response.content
         assert response.content == mode.encode()
 
     check_switch_to_mode('stopped')
@@ -185,7 +186,7 @@ async def test_api_responsive_during_large_upload(test_detector_node: DetectorNo
     with open(test_image_path, 'rb') as f:
         image_bytes = f.read()
 
-    for _ in range(100):
+    for _ in range(200):
         test_detector_node.outbox.save(image_bytes)
 
     outbox_size_early = len(get_outbox_files(test_detector_node.outbox))
@@ -193,8 +194,9 @@ async def test_api_responsive_during_large_upload(test_detector_node: DetectorNo
 
     # check if api is still responsive
     response = requests.get(f'http://localhost:{GLOBALS.detector_port}/outbox_mode', timeout=2)
-    assert response.status_code == 200
+    assert response.status_code == 200, response.content
 
     await asyncio.sleep(5)
     outbox_size_late = len(get_outbox_files(test_detector_node.outbox))
-    assert outbox_size_early > outbox_size_late > 0, 'The outbox should have been partially emptied.'
+    assert outbox_size_late > 0, 'The outbox should not be fully cleared, maybe the node was too fast.'
+    assert outbox_size_early > outbox_size_late, 'The outbox should have been partially emptied.'

learning_loop_node/tests/detector/test_detector_node.py

@@ -0,0 +1,86 @@
+import numpy as np
+import pytest
+
+from learning_loop_node.detector.detector_node import DetectorNode
+
+
+@pytest.mark.asyncio
+async def test_get_detections(detector_node: DetectorNode, monkeypatch):
+    # Mock raw image data
+    raw_image = np.zeros((100, 100, 3), dtype=np.uint8)
+
+    # Mock relevance_filter and outbox
+    filtered_upload_called = False
+    save_called = False
+
+    save_args = []
+
+    def mock_filtered_upload(*args, **kwargs):  # pylint: disable=unused-argument
+        nonlocal filtered_upload_called
+        filtered_upload_called = True
+
+    def mock_save(*args, **kwargs):
+        nonlocal save_called
+        nonlocal save_args
+        save_called = True
+        save_args = (args, kwargs)
+
+    monkeypatch.setattr(detector_node.relevance_filter, "may_upload_detections", mock_filtered_upload)
+    monkeypatch.setattr(detector_node.outbox, "save", mock_save)
+
+    # Test cases
+    test_cases = [
+        (None, True, False),
+        ("filtered", True, False),
+        ("all", False, True),
+        ("disabled", False, False),
+    ]
+
+    expected_save_args = {
+        'image': raw_image,
+        'detections': detector_node.detector_logic.detections,  # type: ignore
+        'tags': ['test_tag'],
+        'source': 'test_source',
+    }
+
+    for autoupload, expect_filtered, expect_all in test_cases:
+        filtered_upload_called = False
+        save_called = False
+
+        result = await detector_node.get_detections(
+            raw_image=raw_image,
+            camera_id="test_camera",
+            tags=["test_tag"],
+            source="test_source",
+            autoupload=autoupload
+        )
+
+        # Check if detections were processed
+        assert result is not None
+        assert result.box_detections is not None
+        assert len(result.box_detections) == 1
+        assert result.box_detections[0].category_name == "test"
+
+        # Check if the correct upload method was called
+        assert filtered_upload_called == expect_filtered
+        assert save_called == expect_all
+
+        if save_called:
+            save_pos_args, save_kwargs = save_args  # pylint: disable=unbalanced-tuple-unpacking
+            expected_values = list(expected_save_args.values())
+            assert len(save_pos_args) + len(save_kwargs) == len(expected_values)
+
+            # Check positional arguments
+            for arg, expected in zip(save_pos_args, expected_values[:len(save_pos_args)]):
+                if isinstance(arg, (list, np.ndarray)):
+                    assert np.array_equal(arg, expected)
+                else:
+                    assert arg == expected
+
+            # Check keyword arguments
+            for key, value in save_kwargs.items():
+                expected = expected_save_args[key]
+                if isinstance(value, (list, np.ndarray)):
+                    assert np.array_equal(value, expected)
+                else:
+                    assert value == expected

learning_loop_node/tests/trainer/conftest.py

@@ -1,7 +1,6 @@
-from ...globals import GLOBALS
-import shutil
 import logging
 import os
+import shutil
 import socket
 from multiprocessing import log_to_stderr
 
@@ -9,6 +8,7 @@ import icecream
 import pytest
 
 from ...data_classes import Context
+from ...globals import GLOBALS
 from ...trainer.trainer_node import TrainerNode
 from .testing_trainer_logic import TestingTrainerLogic
 
@@ -23,8 +23,8 @@ icecream.install()
 
 @pytest.fixture()
 async def test_initialized_trainer_node():
-    os.environ['ORGANIZATION'] = 'zauberzeug'
-    os.environ['PROJECT'] = 'demo'
+    os.environ['LOOP_ORGANIZATION'] = 'zauberzeug'
+    os.environ['LOOP_PROJECT'] = 'demo'
 
     trainer = TestingTrainerLogic()
     node = TrainerNode(name='test', trainer_logic=trainer, uuid='NOD30000-0000-0000-0000-000000000000')

learning_loop_node/tests/trainer/states/test_state_detecting.py

@@ -7,11 +7,10 @@ from ..state_helper import assert_training_state, create_active_training_file
 from ..testing_trainer_logic import TestingTrainerLogic
 
 # pylint: disable=protected-access
-error_key = 'detecting'
 
 
-def trainer_has_error(trainer: TrainerLogic):
-    return trainer.errors.has_error_for(error_key)
+def trainer_has_detecting_error(trainer: TrainerLogic):
+    return trainer.errors.has_error_for('detecting')
 
 
 async def test_successful_detecting(test_initialized_trainer: TestingTrainerLogic):
@@ -25,7 +24,7 @@ async def test_successful_detecting(test_initialized_trainer: TestingTrainerLogi
     await assert_training_state(trainer.training, TrainerState.Detecting, timeout=1, interval=0.001)
     await assert_training_state(trainer.training, TrainerState.Detected, timeout=10, interval=0.001)
 
-    assert trainer_has_error(trainer) is False
+    assert trainer_has_detecting_error(trainer) is False
     assert trainer.training.training_state == TrainerState.Detected
     assert trainer.node.last_training_io.load() == trainer.training
     assert trainer.active_training_io.detections_exist()
@@ -37,7 +36,7 @@ async def test_detecting_can_be_aborted(test_initialized_trainer: TestingTrainer
     trainer._init_from_last_training()
     trainer.training.model_uuid_for_detecting = '12345678-bobo-7e92-f95f-424242424242'
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
     await assert_training_state(trainer.training, TrainerState.Detecting, timeout=5, interval=0.001)
     await trainer.stop()
@@ -54,13 +53,13 @@ async def test_model_not_downloadable_error(test_initialized_trainer: TestingTra
                                 model_uuid_for_detecting='00000000-0000-0000-0000-000000000000')  # bad model id
     trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
-    await assert_training_state(trainer.training, 'detecting', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, 'train_model_uploaded', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.Detecting, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainModelUploaded, timeout=5, interval=0.001)
     await asyncio.sleep(0.1)
 
-    assert trainer_has_error(trainer)
+    assert trainer_has_detecting_error(trainer)
     assert trainer.training.training_state == TrainerState.TrainModelUploaded
     assert trainer.training.model_uuid_for_detecting == '00000000-0000-0000-0000-000000000000'
     assert trainer.node.last_training_io.load() == trainer.training

learning_loop_node/tests/trainer/states/test_state_download_train_model.py

@@ -20,8 +20,8 @@ async def test_downloading_is_successful(test_initialized_trainer: TestingTraine
         trainer._perform_state('download_model',
                                TrainerState.TrainModelDownloading,
                                TrainerState.TrainModelDownloaded, trainer._download_model))
-    await assert_training_state(trainer.training, 'train_model_downloading', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, 'train_model_downloaded', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainModelDownloading, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainModelDownloaded, timeout=10, interval=0.001)
 
     assert trainer.training.training_state == TrainerState.TrainModelDownloaded
     assert trainer.node.last_training_io.load() == trainer.training
@@ -34,11 +34,11 @@ async def test_downloading_is_successful(test_initialized_trainer: TestingTraine
 
 async def test_abort_download_model(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
-    create_active_training_file(trainer, training_state='data_downloaded')
+    create_active_training_file(trainer, training_state=TrainerState.DataDownloaded)
     trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
-    await assert_training_state(trainer.training, 'train_model_downloading', timeout=1, interval=0.001)
+    trainer._begin_training_task()
+    await assert_training_state(trainer.training, TrainerState.TrainModelDownloading, timeout=1, interval=0.001)
 
     await trainer.stop()
     await asyncio.sleep(0.1)
@@ -53,9 +53,9 @@ async def test_downloading_failed(test_initialized_trainer: TestingTrainerLogic)
                                 base_model_uuid_or_name='00000000-0000-0000-0000-000000000000')  # bad model id)
     trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
-    await assert_training_state(trainer.training, 'train_model_downloading', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, TrainerState.DataDownloaded, timeout=1, interval=0.001)
+    trainer._begin_training_task()
+    await assert_training_state(trainer.training, TrainerState.TrainModelDownloading, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.DataDownloaded, timeout=10, interval=0.001)
 
     assert trainer.errors.has_error_for('download_model')
     assert trainer._training is not None  # pylint: disable=protected-access

learning_loop_node/tests/trainer/states/test_state_prepare.py

@@ -6,11 +6,10 @@ from ..state_helper import assert_training_state, create_active_training_file
 from ..testing_trainer_logic import TestingTrainerLogic
 
 # pylint: disable=protected-access
-error_key = 'prepare'
 
 
-def trainer_has_error(trainer: TrainerLogic):
-    return trainer.errors.has_error_for(error_key)
+def trainer_has_prepare_error(trainer: TrainerLogic):
+    return trainer.errors.has_error_for('prepare')
 
 
 async def test_preparing_is_successful(test_initialized_trainer: TestingTrainerLogic):
@@ -19,7 +18,7 @@ async def test_preparing_is_successful(test_initialized_trainer: TestingTrainerL
     trainer._init_from_last_training()
 
     await trainer._perform_state('prepare', TrainerState.DataDownloading, TrainerState.DataDownloaded, trainer._prepare)
-    assert trainer_has_error(trainer) is False
+    assert trainer_has_prepare_error(trainer) is False
     assert trainer.training.training_state == TrainerState.DataDownloaded
     assert trainer.training.data is not None
     assert trainer.node.last_training_io.load() == trainer.training
@@ -30,7 +29,7 @@ async def test_abort_preparing(test_initialized_trainer: TestingTrainerLogic):
     create_active_training_file(trainer)
     trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
     await assert_training_state(trainer.training, TrainerState.DataDownloading, timeout=1, interval=0.001)
 
     await trainer.stop()
@@ -48,9 +47,9 @@ async def test_request_error(test_initialized_trainer: TestingTrainerLogic):
 
     _ = asyncio.get_running_loop().create_task(trainer._run())
     await assert_training_state(trainer.training, TrainerState.DataDownloading, timeout=3, interval=0.001)
-    await assert_training_state(trainer.training, TrainerState.Initialized, timeout=3, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.Initialized, timeout=10, interval=0.001)
 
-    assert trainer_has_error(trainer)
+    assert trainer_has_prepare_error(trainer)
     assert trainer._training is not None  # pylint: disable=protected-access
     assert trainer.training.training_state == TrainerState.Initialized
     assert trainer.node.last_training_io.load() == trainer.training

learning_loop_node/tests/trainer/states/test_state_sync_confusion_matrix.py

@@ -11,11 +11,9 @@ from ..testing_trainer_logic import TestingTrainerLogic
 
 # pylint: disable=protected-access
 
-error_key = 'sync_confusion_matrix'
 
-
-def trainer_has_error(trainer: TrainerLogic):
-    return trainer.errors.has_error_for(error_key)
+def trainer_has_sync_confusion_matrix_error(trainer: TrainerLogic):
+    return trainer.errors.has_error_for('sync_confusion_matrix')
 
 
 async def test_nothing_to_sync(test_initialized_trainer: TestingTrainerLogic):
@@ -26,10 +24,10 @@ async def test_nothing_to_sync(test_initialized_trainer: TestingTrainerLogic):
     create_active_training_file(trainer, training_state=TrainerState.TrainingFinished)
     trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
     await assert_training_state(trainer.training, TrainerState.ConfusionMatrixSynced, timeout=1, interval=0.001)
-    assert trainer_has_error(trainer) is False
+    assert trainer_has_sync_confusion_matrix_error(trainer) is False
     assert trainer.training.training_state == TrainerState.ConfusionMatrixSynced
     assert trainer.node.last_training_io.load() == trainer.training
 
@@ -38,16 +36,16 @@ async def test_unsynced_model_available__sync_successful(test_initialized_traine
     trainer = test_initialized_trainer_node.trainer_logic
     assert isinstance(trainer, TestingTrainerLogic)
 
-    await mock_socket_io_call(mocker, test_initialized_trainer_node, {'success': True})
+    await mock_socket_io_call(mocker, test_initialized_trainer_node, return_value={'success': True})
     create_active_training_file(trainer, training_state=TrainerState.TrainingFinished)
 
     trainer._init_from_last_training()
     trainer.has_new_model = True
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
     await assert_training_state(trainer.training, TrainerState.ConfusionMatrixSynced, timeout=1, interval=0.001)
 
-    assert trainer_has_error(trainer) is False
+    assert trainer_has_sync_confusion_matrix_error(trainer) is False
 #    assert trainer.training.training_state == TrainerState.ConfusionMatrixSynced
     assert trainer.node.last_training_io.load() == trainer.training
 
@@ -56,17 +54,19 @@ async def test_unsynced_model_available__sio_not_connected(test_initialized_trai
     trainer = test_initialized_trainer_node.trainer_logic
     assert isinstance(trainer, TestingTrainerLogic)
 
+    await test_initialized_trainer_node.sio_client.disconnect()
+    test_initialized_trainer_node.set_skip_repeat_loop(True)
     create_active_training_file(trainer, training_state=TrainerState.TrainingFinished)
 
     assert test_initialized_trainer_node.sio_client.connected is False
     trainer.has_new_model = True
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
-    await assert_training_state(trainer.training, 'confusion_matrix_syncing', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.ConfusionMatrixSyncing, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=10, interval=0.001)
 
-    assert trainer_has_error(trainer)
+    assert trainer_has_sync_confusion_matrix_error(trainer)  # Due to sio not being connected, the request will fail
     assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training
 
@@ -75,17 +75,17 @@ async def test_unsynced_model_available__request_is_not_successful(test_initiali
     trainer = test_initialized_trainer_node.trainer_logic
     assert isinstance(trainer, TestingTrainerLogic)
 
-    await mock_socket_io_call(mocker, test_initialized_trainer_node, {'success': False})
+    await mock_socket_io_call(mocker, test_initialized_trainer_node, return_value={'success': False})
 
     create_active_training_file(trainer, training_state=TrainerState.TrainingFinished)
 
     trainer.has_new_model = True
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
-    await assert_training_state(trainer.training, 'confusion_matrix_syncing', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.ConfusionMatrixSyncing, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=10, interval=0.001)
 
-    assert trainer_has_error(trainer)
+    assert trainer_has_sync_confusion_matrix_error(trainer)  # Due to sio call failure, the error will be set
     assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training
 
@@ -100,6 +100,9 @@ async def test_basic_mock(test_initialized_trainer_node: TrainerNode, mocker: Mo
 
 
 async def mock_socket_io_call(mocker, trainer_node: TrainerNode, return_value):
+    '''
+    Patch the socketio call function to always return the given return_value
+    '''
     for _ in range(10):
         if trainer_node.sio_client is None:
             await asyncio.sleep(0.1)

learning_loop_node/tests/trainer/states/test_state_train.py

@@ -14,10 +14,10 @@ async def test_successful_training(test_initialized_trainer: TestingTrainerLogic
     create_active_training_file(trainer, training_state=TrainerState.TrainModelDownloaded)
     trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
     await condition(lambda: trainer._executor and trainer._executor.is_running(), timeout=1, interval=0.01)
-    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=1, interval=0.01)
+    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=10, interval=0.01)
     assert trainer.start_training_task is not None
 
     assert trainer._executor is not None
@@ -34,16 +34,15 @@ async def test_stop_running_training(test_initialized_trainer: TestingTrainerLog
     create_active_training_file(trainer, training_state=TrainerState.TrainModelDownloaded)
     trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
     await condition(lambda: trainer._executor and trainer._executor.is_running(), timeout=1, interval=0.01)
-    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=1, interval=0.01)
+    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=10, interval=0.01)
     assert trainer.start_training_task is not None
 
     await trainer.stop()
     await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=2, interval=0.01)
 
-    assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training
 
 
@@ -55,15 +54,14 @@ async def test_training_can_maybe_resumed(test_initialized_trainer: TestingTrain
     trainer._init_from_last_training()
     trainer._can_resume_flag = True
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
     await condition(lambda: trainer._executor and trainer._executor.is_running(), timeout=1, interval=0.01)
-    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=10, interval=0.001)
     assert trainer.start_training_task is not None
 
     assert trainer._executor is not None
     await trainer._executor.stop_and_wait()  # NOTE normally a training terminates itself e.g
     await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=1, interval=0.001)
 
-    assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training

learning_loop_node/tests/trainer/states/test_state_upload_detections.py

@@ -11,11 +11,10 @@ from ..state_helper import assert_training_state, create_active_training_file
 from ..testing_trainer_logic import TestingTrainerLogic
 
 # pylint: disable=protected-access
-error_key = 'upload_detections'
 
 
-def trainer_has_error(trainer: TrainerLogic):
-    return trainer.errors.has_error_for(error_key)
+def trainer_has_upload_detections_error(trainer: TrainerLogic):
+    return trainer.errors.has_error_for('upload_detections')
 
 
 async def create_valid_detection_file(trainer: TrainerLogic, number_of_entries: int = 1, file_index: int = 0):
@@ -125,12 +124,11 @@ async def test_bad_status_from_LearningLoop(test_initialized_trainer: TestingTra
     trainer._init_from_last_training()
     trainer.active_training_io.save_detections([get_dummy_detections()])
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
     await assert_training_state(trainer.training, TrainerState.DetectionUploading, timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, TrainerState.Detected, timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.Detected, timeout=10, interval=0.001)
 
-    assert trainer_has_error(trainer)
-    assert trainer.training.training_state == TrainerState.Detected
+    assert trainer_has_upload_detections_error(trainer)
     assert trainer.node.last_training_io.load() == trainer.training
 
 
@@ -143,7 +141,7 @@ async def test_go_to_cleanup_if_no_detections_exist(test_initialized_trainer: Te
     create_active_training_file(trainer, training_state=TrainerState.Detected)
     trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
     await assert_training_state(trainer.training, TrainerState.ReadyForCleanup, timeout=1, interval=0.001)
 
 
@@ -154,7 +152,7 @@ async def test_abort_uploading(test_initialized_trainer: TestingTrainerLogic):
     trainer._init_from_last_training()
     await create_valid_detection_file(trainer)
 
-    _ = asyncio.get_running_loop().create_task(trainer._run())
+    trainer._begin_training_task()
 
     await assert_training_state(trainer.training, TrainerState.DetectionUploading, timeout=1, interval=0.001)