learning-loop-node 0.9.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

learning_loop_node/trainer/tests/states/test_state_download_train_model.py

@@ -2,22 +2,28 @@
 import asyncio
 import os
 
+from learning_loop_node.data_classes import TrainerState
 from learning_loop_node.trainer.tests.state_helper import assert_training_state, create_active_training_file
 from learning_loop_node.trainer.tests.testing_trainer_logic import TestingTrainerLogic
 
+# pylint: disable=protected-access
+
 
 async def test_downloading_is_successful(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.model_format = 'mocked'
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.download_model())
+    asyncio.get_running_loop().create_task(
+        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)
 
-    assert trainer.training.training_state == 'train_model_downloaded'
+    assert trainer.training.training_state == TrainerState.TrainModelDownloaded
     assert trainer.node.last_training_io.load() == trainer.training
 
     # file on disk
@@ -29,9 +35,9 @@ 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')
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
     await assert_training_state(trainer.training, 'train_model_downloading', timeout=1, interval=0.001)
 
     await trainer.stop()
@@ -43,15 +49,15 @@ async def test_abort_download_model(test_initialized_trainer: TestingTrainerLogi
 
 async def test_downloading_failed(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
-    create_active_training_file(trainer, training_state='data_downloaded',
-                                base_model_id='00000000-0000-0000-0000-000000000000')  # bad model id)
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.DataDownloaded,
+                                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())
+    _ = 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, 'data_downloaded', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.DataDownloaded, timeout=1, interval=0.001)
 
     assert trainer.errors.has_error_for('download_model')
     assert trainer._training is not None  # pylint: disable=protected-access
-    assert trainer.training.training_state == 'data_downloaded'
+    assert trainer.training.training_state == TrainerState.DataDownloaded
     assert trainer.node.last_training_io.load() == trainer.training

learning_loop_node/trainer/tests/states/test_state_prepare.py

@@ -1,10 +1,11 @@
 import asyncio
 
-from learning_loop_node.data_classes import Context
+from learning_loop_node.data_classes import Context, TrainerState
 from learning_loop_node.trainer.tests.state_helper import assert_training_state, create_active_training_file
 from learning_loop_node.trainer.tests.testing_trainer_logic import TestingTrainerLogic
 from learning_loop_node.trainer.trainer_logic import TrainerLogic
 
+# pylint: disable=protected-access
 error_key = 'prepare'
 
 
@@ -15,11 +16,11 @@ def trainer_has_error(trainer: TrainerLogic):
 async def test_preparing_is_successful(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
     create_active_training_file(trainer)
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
 
-    await trainer.prepare()
+    await trainer._perform_state('prepare', TrainerState.DataDownloading, TrainerState.DataDownloaded, trainer._prepare)
     assert trainer_has_error(trainer) is False
-    assert trainer.training.training_state == 'data_downloaded'
+    assert trainer.training.training_state == TrainerState.DataDownloaded
     assert trainer.training.data is not None
     assert trainer.node.last_training_io.load() == trainer.training
 
@@ -27,10 +28,10 @@ async def test_preparing_is_successful(test_initialized_trainer: TestingTrainerL
 async def test_abort_preparing(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
     create_active_training_file(trainer)
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
-    await assert_training_state(trainer.training, 'data_downloading', timeout=1, interval=0.001)
+    _ = asyncio.get_running_loop().create_task(trainer._run())
+    await assert_training_state(trainer.training, TrainerState.DataDownloading, timeout=1, interval=0.001)
 
     await trainer.stop()
     await asyncio.sleep(0.1)
@@ -43,13 +44,13 @@ async def test_request_error(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
     create_active_training_file(trainer, context=Context(
         organization='zauberzeug', project='some_bad_project'))
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
-    await assert_training_state(trainer.training, 'data_downloading', timeout=3, interval=0.001)
-    await assert_training_state(trainer.training, 'initialized', timeout=3, interval=0.001)
+    _ = 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)
 
     assert trainer_has_error(trainer)
     assert trainer._training is not None  # pylint: disable=protected-access
-    assert trainer.training.training_state == 'initialized'
+    assert trainer.training.training_state == TrainerState.Initialized
     assert trainer.node.last_training_io.load() == trainer.training

learning_loop_node/trainer/tests/states/test_state_sync_confusion_matrix.py

@@ -3,12 +3,15 @@ import asyncio
 
 from pytest_mock import MockerFixture  # pip install pytest-mock
 
+from learning_loop_node.data_classes import TrainerState
 from learning_loop_node.trainer.trainer_logic import TrainerLogic
 from learning_loop_node.trainer.trainer_node import TrainerNode
 
 from ..state_helper import assert_training_state, create_active_training_file
 from ..testing_trainer_logic import TestingTrainerLogic
 
+# pylint: disable=protected-access
+
 error_key = 'sync_confusion_matrix'
 
 
@@ -21,14 +24,14 @@ async def test_nothing_to_sync(test_initialized_trainer: TestingTrainerLogic):
 
     # TODO this requires trainer to have _training
     # trainer.load_active_training()
-    create_active_training_file(trainer, training_state='training_finished')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.TrainingFinished)
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
-    await assert_training_state(trainer.training, 'confusion_matrix_synced', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.ConfusionMatrixSynced, timeout=1, interval=0.001)
     assert trainer_has_error(trainer) is False
-    assert trainer.training.training_state == 'confusion_matrix_synced'
+    assert trainer.training.training_state == TrainerState.ConfusionMatrixSynced
     assert trainer.node.last_training_io.load() == trainer.training
 
 
@@ -37,16 +40,16 @@ async def test_unsynced_model_available__sync_successful(test_initialized_traine
     assert isinstance(trainer, TestingTrainerLogic)
 
     await mock_socket_io_call(mocker, test_initialized_trainer_node, {'success': True})
-    create_active_training_file(trainer, training_state='training_finished')
+    create_active_training_file(trainer, training_state=TrainerState.TrainingFinished)
 
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
     trainer.has_new_model = True
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
-    await assert_training_state(trainer.training, 'confusion_matrix_synced', timeout=1, interval=0.001)
+    _ = asyncio.get_running_loop().create_task(trainer._run())
+    await assert_training_state(trainer.training, TrainerState.ConfusionMatrixSynced, timeout=1, interval=0.001)
 
     assert trainer_has_error(trainer) is False
-#    assert trainer.training.training_state == 'confusion_matrix_synced'
+#    assert trainer.training.training_state == TrainerState.ConfusionMatrixSynced
     assert trainer.node.last_training_io.load() == trainer.training
 
 
@@ -54,18 +57,18 @@ async def test_unsynced_model_available__sio_not_connected(test_initialized_trai
     trainer = test_initialized_trainer_node.trainer_logic
     assert isinstance(trainer, TestingTrainerLogic)
 
-    create_active_training_file(trainer, training_state='training_finished')
+    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())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
     await assert_training_state(trainer.training, 'confusion_matrix_syncing', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, 'training_finished', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=1, interval=0.001)
 
     assert trainer_has_error(trainer)
-    assert trainer.training.training_state == 'training_finished'
+    assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training
 
 
@@ -75,16 +78,16 @@ async def test_unsynced_model_available__request_is_not_successful(test_initiali
 
     await mock_socket_io_call(mocker, test_initialized_trainer_node, {'success': False})
 
-    create_active_training_file(trainer, training_state='training_finished')
+    create_active_training_file(trainer, training_state=TrainerState.TrainingFinished)
 
     trainer.has_new_model = True
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
     await assert_training_state(trainer.training, 'confusion_matrix_syncing', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, 'training_finished', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=1, interval=0.001)
 
     assert trainer_has_error(trainer)
-    assert trainer.training.training_state == 'training_finished'
+    assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training
 
 

learning_loop_node/trainer/tests/states/test_state_train.py

@@ -1,48 +1,49 @@
 import asyncio
 
+from learning_loop_node.data_classes import TrainerState
 from learning_loop_node.tests.test_helper import condition
 from learning_loop_node.trainer.tests.state_helper import assert_training_state, create_active_training_file
 from learning_loop_node.trainer.tests.testing_trainer_logic import TestingTrainerLogic
 
+# pylint: disable=protected-access
+
 
 async def test_successful_training(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
 
-    create_active_training_file(trainer, training_state='train_model_downloaded')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.TrainModelDownloaded)
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
-    await assert_training_state(trainer.training, 'training_running', timeout=1, interval=0.001)
+    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)
     assert trainer.start_training_task is not None
-    assert trainer.start_training_task.__name__ == 'start_training'
 
-    # pylint: disable=protected-access
     assert trainer._executor is not None
-    trainer._executor.stop()  # NOTE normally a training terminates itself
-    await assert_training_state(trainer.training, 'training_finished', timeout=1, interval=0.001)
+    await trainer.stop()  # NOTE normally a training terminates itself
+    await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=1, interval=0.001)
 
-    assert trainer.training.training_state == 'training_finished'
+    assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training
 
 
 async def test_stop_running_training(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
 
-    create_active_training_file(trainer, training_state='train_model_downloaded')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.TrainModelDownloaded)
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
-    await condition(lambda: trainer._executor and trainer._executor.is_process_running(), timeout=1, interval=0.01)  # pylint: disable=protected-access
-    await assert_training_state(trainer.training, 'training_running', timeout=1, interval=0.001)
+    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)
     assert trainer.start_training_task is not None
-    assert trainer.start_training_task.__name__ == 'start_training'
 
     await trainer.stop()
-    await assert_training_state(trainer.training, 'training_finished', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainingFinished, timeout=2, interval=0.01)
 
-    assert trainer.training.training_state == 'training_finished'
+    assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training
 
 
@@ -50,21 +51,19 @@ async def test_training_can_maybe_resumed(test_initialized_trainer: TestingTrain
     trainer = test_initialized_trainer
 
     # NOTE e.g. when a node-computer is restarted
-    create_active_training_file(trainer, training_state='train_model_downloaded')
-    trainer.init_from_last_training()
-    trainer._can_resume = True  # pylint: disable=protected-access
+    create_active_training_file(trainer, training_state=TrainerState.TrainModelDownloaded)
+    trainer._init_from_last_training()
+    trainer._can_resume_flag = True
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
-    await condition(lambda: trainer._executor and trainer._executor.is_process_running(), timeout=1, interval=0.01)  # pylint: disable=protected-access
-    await assert_training_state(trainer.training, 'training_running', timeout=1, interval=0.001)
+    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)
     assert trainer.start_training_task is not None
-    assert trainer.start_training_task.__name__ == 'resume'
 
-    # pylint: disable=protected-access
     assert trainer._executor is not None
-    trainer._executor.stop()  # NOTE normally a training terminates itself e.g
-    await assert_training_state(trainer.training, 'training_finished', timeout=1, interval=0.001)
+    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 == 'training_finished'
+    assert trainer.training.training_state == TrainerState.TrainingFinished
     assert trainer.node.last_training_io.load() == trainer.training

learning_loop_node/trainer/tests/states/test_state_upload_detections.py

@@ -4,12 +4,13 @@ import pytest
 from dacite import from_dict
 
 from learning_loop_node.conftest import get_dummy_detections
-from learning_loop_node.data_classes import BoxDetection, Context, Detections
+from learning_loop_node.data_classes import BoxDetection, Context, Detections, TrainerState
 from learning_loop_node.loop_communication import LoopCommunicator
 from learning_loop_node.trainer.tests.state_helper import assert_training_state, create_active_training_file
 from learning_loop_node.trainer.tests.testing_trainer_logic import TestingTrainerLogic
 from learning_loop_node.trainer.trainer_logic import TrainerLogic
 
+# pylint: disable=protected-access
 error_key = 'upload_detections'
 
 
@@ -43,13 +44,14 @@ async def create_valid_detection_file(trainer: TrainerLogic, number_of_entries:
 @pytest.mark.asyncio
 async def test_upload_successful(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
-    create_active_training_file(trainer, training_state='detected')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.Detected)
+    trainer._init_from_last_training()
 
     await create_valid_detection_file(trainer)
-    await trainer.upload_detections()
+    await asyncio.get_running_loop().create_task(
+        trainer._perform_state('upload_detections', TrainerState.DetectionUploading, TrainerState.ReadyForCleanup, trainer.active_training_io.upload_detetions))
 
-    assert trainer.training.training_state == 'ready_for_cleanup'
+    assert trainer.training.training_state == TrainerState.ReadyForCleanup
     assert trainer.node.last_training_io.load() == trainer.training
 
 
@@ -57,13 +59,16 @@ async def test_upload_successful(test_initialized_trainer: TestingTrainerLogic):
 async def test_detection_upload_progress_is_stored(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
 
-    create_active_training_file(trainer, training_state='detected')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.Detected)
+    trainer._init_from_last_training()
 
     await create_valid_detection_file(trainer)
 
     assert trainer.active_training_io.load_detections_upload_file_index() == 0
-    await trainer.upload_detections()
+    # await trainer.upload_detections()
+    await asyncio.get_running_loop().create_task(
+        trainer._perform_state('upload_detections', TrainerState.DetectionUploading, TrainerState.ReadyForCleanup, trainer.active_training_io.upload_detetions))
+
     assert trainer.active_training_io.load_detection_upload_progress() == 0  # Progress is reset for every file
     assert trainer.active_training_io.load_detections_upload_file_index() == 1
 
@@ -72,8 +77,8 @@ async def test_detection_upload_progress_is_stored(test_initialized_trainer: Tes
 async def test_ensure_all_detections_are_uploaded(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
 
-    create_active_training_file(trainer, training_state='detected')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.Detected)
+    trainer._init_from_last_training()
 
     await create_valid_detection_file(trainer, 2, 0)
     await create_valid_detection_file(trainer, 2, 1)
@@ -87,7 +92,7 @@ async def test_ensure_all_detections_are_uploaded(test_initialized_trainer: Test
     for i in range(skip_detections, len(detections), batch_size):
         batch_detections = detections[i:i+batch_size]
         # pylint: disable=protected-access
-        await trainer._upload_detections(trainer.training.context, batch_detections, i + batch_size)
+        await trainer.active_training_io._upload_detections(trainer.training.context, batch_detections, i + batch_size)
 
         expected_value = i + batch_size if i + batch_size < len(detections) else 0  # Progress is reset for every file
         assert trainer.active_training_io.load_detection_upload_progress() == expected_value
@@ -103,7 +108,7 @@ async def test_ensure_all_detections_are_uploaded(test_initialized_trainer: Test
     for i in range(skip_detections, len(detections), batch_size):
         batch_detections = detections[i:i+batch_size]
         # pylint: disable=protected-access
-        await trainer._upload_detections(trainer.training.context, batch_detections, i + batch_size)
+        await trainer.active_training_io._upload_detections(trainer.training.context, batch_detections, i + batch_size)
 
         expected_value = i + batch_size if i + batch_size < len(detections) else 0  # Progress is reset for every file
         assert trainer.active_training_io.load_detection_upload_progress() == expected_value
@@ -114,46 +119,43 @@ async def test_ensure_all_detections_are_uploaded(test_initialized_trainer: Test
 async def test_bad_status_from_LearningLoop(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
 
-    create_active_training_file(trainer, training_state='detected', context=Context(
+    create_active_training_file(trainer, training_state=TrainerState.Detected, context=Context(
         organization='zauberzeug', project='some_bad_project'))
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
     trainer.active_training_io.save_detections([get_dummy_detections()])
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
-    await assert_training_state(trainer.training, 'detection_uploading', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, 'detected', timeout=1, interval=0.001)
+    _ = asyncio.get_running_loop().create_task(trainer._run())
+    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)
 
     assert trainer_has_error(trainer)
-    assert trainer.training.training_state == 'detected'
+    assert trainer.training.training_state == TrainerState.Detected
     assert trainer.node.last_training_io.load() == trainer.training
 
 
-async def test_other_errors(test_initialized_trainer: TestingTrainerLogic):
+async def test_go_to_cleanup_if_no_detections_exist(test_initialized_trainer: TestingTrainerLogic):
+    """This test simulates a situation where the detection file is missing.
+    In this case, the trainer should report an error and move to the ReadyForCleanup state."""
     trainer = test_initialized_trainer
 
     # e.g. missing detection file
-    create_active_training_file(trainer, training_state='detected')
-    trainer.init_from_last_training()
-
-    _ = asyncio.get_running_loop().create_task(trainer.run())
-    await assert_training_state(trainer.training, 'detection_uploading', timeout=1, interval=0.001)
-    await assert_training_state(trainer.training, 'detected', timeout=1, interval=0.001)
+    create_active_training_file(trainer, training_state=TrainerState.Detected)
+    trainer._init_from_last_training()
 
-    assert trainer_has_error(trainer)
-    assert trainer.training.training_state == 'detected'
-    assert trainer.node.last_training_io.load() == trainer.training
+    _ = asyncio.get_running_loop().create_task(trainer._run())
+    await assert_training_state(trainer.training, TrainerState.ReadyForCleanup, timeout=1, interval=0.001)
 
 
 async def test_abort_uploading(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
 
-    create_active_training_file(trainer, training_state='detected')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.Detected)
+    trainer._init_from_last_training()
     await create_valid_detection_file(trainer)
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
-    await assert_training_state(trainer.training, 'detection_uploading', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.DetectionUploading, timeout=1, interval=0.001)
 
     await trainer.stop()
     await asyncio.sleep(0.1)

learning_loop_node/trainer/tests/states/test_state_upload_model.py

@@ -2,11 +2,12 @@ import asyncio
 
 from pytest_mock import MockerFixture
 
-from learning_loop_node.data_classes import Context
+from learning_loop_node.data_classes import Context, TrainerState
 from learning_loop_node.trainer.tests.state_helper import assert_training_state, create_active_training_file
 from learning_loop_node.trainer.tests.testing_trainer_logic import TestingTrainerLogic
 from learning_loop_node.trainer.trainer_logic import TrainerLogic
 
+# pylint: disable=protected-access
 error_key = 'upload_model'
 
 
@@ -19,28 +20,29 @@ async def test_successful_upload(mocker: MockerFixture, test_initialized_trainer
     mock_upload_model_for_training(mocker, 'new_model_id')
 
     create_active_training_file(trainer)
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
 
-    train_task = asyncio.get_running_loop().create_task(trainer.upload_model())
+    train_task = asyncio.get_running_loop().create_task(
+        trainer._perform_state('upload_model', TrainerState.TrainModelUploading, TrainerState.TrainModelUploaded, trainer._upload_model))
 
-    await assert_training_state(trainer.training, 'train_model_uploading', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainModelUploading, timeout=1, interval=0.001)
     await train_task
 
     assert trainer_has_error(trainer) is False
-    assert trainer.training.training_state == 'train_model_uploaded'
-    assert trainer.training.model_id_for_detecting is not None
+    assert trainer.training.training_state == TrainerState.TrainModelUploaded
+    assert trainer.training.model_uuid_for_detecting is not None
     assert trainer.node.last_training_io.load() == trainer.training
 
 
 async def test_abort_upload_model(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
 
-    create_active_training_file(trainer, training_state='confusion_matrix_synced')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.ConfusionMatrixSynced)
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
-    await assert_training_state(trainer.training, 'train_model_uploading', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainModelUploading, timeout=1, interval=0.001)
 
     await trainer.stop()
     await asyncio.sleep(0.1)
@@ -55,18 +57,18 @@ async def test_bad_server_response_content(test_initialized_trainer: TestingTrai
     The training should be aborted and the training state should be set to confusion_matrix_synced."""
     trainer = test_initialized_trainer
 
-    create_active_training_file(trainer, training_state='confusion_matrix_synced')
-    trainer.init_from_last_training()
+    create_active_training_file(trainer, training_state=TrainerState.ConfusionMatrixSynced)
+    trainer._init_from_last_training()
 
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
-    await assert_training_state(trainer.training, 'train_model_uploading', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainModelUploading, timeout=1, interval=0.001)
     # TODO goes to finished because of the error
-    await assert_training_state(trainer.training, 'confusion_matrix_synced', timeout=2, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.ConfusionMatrixSynced, timeout=2, interval=0.001)
 
     assert trainer_has_error(trainer)
-    assert trainer.training.training_state == 'confusion_matrix_synced'
-    assert trainer.training.model_id_for_detecting is None
+    assert trainer.training.training_state == TrainerState.ConfusionMatrixSynced
+    assert trainer.training.model_uuid_for_detecting is None
     assert trainer.node.last_training_io.load() == trainer.training
 
 
@@ -76,12 +78,12 @@ async def test_mock_loop_response_example(mocker: MockerFixture, test_initialize
     mock_upload_model_for_training(mocker, 'new_model_id')
 
     create_active_training_file(trainer)
-    trainer.init_from_last_training()
+    trainer._init_from_last_training()
 
     # pylint: disable=protected-access
-    result = await trainer._upload_model_return_new_id(Context(organization='zauberzeug', project='demo'))
+    result = await trainer._upload_model_return_new_model_uuid(Context(organization='zauberzeug', project='demo'))
     assert result is not None
 
 
 def mock_upload_model_for_training(mocker, return_value):
-    mocker.patch('learning_loop_node.data_exchanger.DataExchanger.upload_model_for_training', return_value=return_value)
+    mocker.patch('learning_loop_node.data_exchanger.DataExchanger.upload_model_get_uuid', return_value=return_value)

learning_loop_node/trainer/tests/test_errors.py

@@ -1,37 +1,45 @@
 import asyncio
 import re
 
+import pytest
+
+from learning_loop_node.data_classes import TrainerState
 from learning_loop_node.trainer.tests.state_helper import assert_training_state, create_active_training_file
 from learning_loop_node.trainer.tests.testing_trainer_logic import TestingTrainerLogic
 
+# pylint: disable=protected-access
+
 
 async def test_training_process_is_stopped_when_trainer_reports_error(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
-    create_active_training_file(trainer, training_state='train_model_downloaded')
-    trainer.init_from_last_training()
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    create_active_training_file(trainer, training_state=TrainerState.TrainModelDownloaded)
+    trainer._init_from_last_training()
+    _ = asyncio.get_running_loop().create_task(trainer._run())
 
-    await assert_training_state(trainer.training, 'training_running', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=1, interval=0.001)
     trainer.error_msg = 'some_error'
-    await assert_training_state(trainer.training, 'train_model_downloaded', timeout=6, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainModelDownloaded, timeout=6, interval=0.001)
 
 
+@pytest.mark.skip(reason='The since_last_start flag is deprecated.')
 async def test_log_can_provide_only_data_for_current_run(test_initialized_trainer: TestingTrainerLogic):
     trainer = test_initialized_trainer
-    create_active_training_file(trainer, training_state='train_model_downloaded')
-    trainer.init_from_last_training()
-    _ = asyncio.get_running_loop().create_task(trainer.run())
+    create_active_training_file(trainer, training_state=TrainerState.TrainModelDownloaded)
+    trainer._init_from_last_training()
+    _ = asyncio.get_running_loop().create_task(trainer._run())
+
+    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=1, interval=0.001)
+    await asyncio.sleep(0.1)  # give tests a bit time to to check for the state
 
-    await assert_training_state(trainer.training, 'training_running', timeout=1, interval=0.001)
     assert trainer._executor is not None
     assert len(re.findall('Starting executor', str(trainer._executor.get_log_by_lines()))) == 1
 
     trainer.error_msg = 'some_error'
-    await assert_training_state(trainer.training, 'train_model_downloaded', timeout=6, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainModelDownloaded, timeout=6, interval=0.001)
     trainer.error_msg = None
-    await assert_training_state(trainer.training, 'training_running', timeout=1, interval=0.001)
+    await assert_training_state(trainer.training, TrainerState.TrainingRunning, timeout=1, interval=0.001)
     await asyncio.sleep(1)
 
     assert len(re.findall('Starting executor', str(trainer._executor.get_log_by_lines()))) > 1
     # Here only the current run is provided
-    assert len(re.findall('Starting executor', str(trainer._executor.get_log_by_lines(since_last_start=True)))) == 1
+    # assert len(re.findall('Starting executor', str(trainer._executor.get_log_by_lines(since_last_start=True)))) == 1