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

learning_loop_node/trainer/tests/test_trainer_states.py

@@ -1,10 +1,9 @@
 
 from uuid import uuid4
 
-from learning_loop_node.data_classes import Context, Training, TrainingState
+from learning_loop_node.data_classes import Context, TrainerState, Training
 from learning_loop_node.trainer.io_helpers import LastTrainingIO
-from learning_loop_node.trainer.tests.testing_trainer_logic import \
-    TestingTrainerLogic
+from learning_loop_node.trainer.tests.testing_trainer_logic import TestingTrainerLogic
 from learning_loop_node.trainer.trainer_node import TrainerNode
 
 
@@ -27,8 +26,8 @@ def test_fixture_trainer_node(test_initialized_trainer_node):
 def test_save_load_training():
     training = create_training()
     last_training_io = LastTrainingIO('00000000-0000-0000-0000-000000000000')
-    training.training_state = TrainingState.Preparing
+    training.training_state = TrainerState.Preparing
     last_training_io.save(training)
 
     training = last_training_io.load()
-    assert training.training_state == 'preparing'
+    assert training.training_state == TrainerState.Preparing

learning_loop_node/trainer/tests/testing_trainer_logic.py

@@ -1,8 +1,8 @@
 import asyncio
 import time
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
-from learning_loop_node.data_classes import BasicModel, Context, Detections, ModelInformation, PretrainedModel
+from learning_loop_node.data_classes import Context, Detections, ModelInformation, PretrainedModel, TrainingStateData
 from learning_loop_node.trainer.trainer_logic import TrainerLogic
 
 
@@ -11,7 +11,7 @@ class TestingTrainerLogic(TrainerLogic):
 
     def __init__(self, can_resume: bool = False) -> None:
         super().__init__('mocked')
-        self._can_resume: bool = can_resume
+        self._can_resume_flag: bool = can_resume
         self.has_new_model: bool = False
         self.error_msg: Optional[str] = None
 
@@ -25,25 +25,25 @@ class TestingTrainerLogic(TrainerLogic):
 
     @property
     def provided_pretrained_models(self) -> List[PretrainedModel]:
-        return [
-            PretrainedModel(name='small', label='Small', description='a small model'),
-            PretrainedModel(name='medium', label='Medium', description='a medium model'),
-            PretrainedModel(name='large', label='Large', description='a large model')]
+        return [PretrainedModel(name='small', label='Small', description='a small model'),
+                PretrainedModel(name='medium', label='Medium', description='a medium model'),
+                PretrainedModel(name='large', label='Large', description='a large model')]
 
     # pylint: disable=unused-argument
-    async def start_training(self, model: str = 'model.model') -> None:
+    async def _start_training_from_base_model(self, model: str = 'model.model') -> None:
         assert self._executor is not None
-        self._executor.start('while true; do sleep 1; done')
+        await self._executor.start('/bin/bash -c "while true; do sleep 1; done"')
 
-    async def start_training_from_scratch(self, base_model_id: str) -> None:
-        await self.start_training(model=f'model_{base_model_id}.pt')
+    async def _start_training_from_scratch(self) -> None:
+        assert self.training.base_model_uuid_or_name is not None, 'base_model_uuid_or_name must be set'
+        await self._start_training_from_base_model(model=f'model_{self.training.base_model_uuid_or_name}.pt')
 
-    def get_new_model(self) -> Optional[BasicModel]:
+    def _get_new_best_training_state(self) -> Optional[TrainingStateData]:
         if self.has_new_model:
-            return BasicModel(confusion_matrix={})
+            return TrainingStateData(confusion_matrix={})
         return None
 
-    def on_model_published(self, basic_model: BasicModel) -> None:
+    def _on_metrics_published(self, training_state_data: TrainingStateData) -> None:
         pass
 
     async def _prepare(self) -> None:
@@ -54,24 +54,19 @@ class TestingTrainerLogic(TrainerLogic):
         await super()._download_model()
         await asyncio.sleep(0.1)  # give tests a bit time to to check for the state
 
-    async def ensure_confusion_matrix_synced(self):
+    async def _upload_model(self) -> None:
         await asyncio.sleep(0.1)  # give tests a bit time to to check for the state
-        await super().ensure_confusion_matrix_synced()
+        await super()._upload_model()
         await asyncio.sleep(0.1)  # give tests a bit time to to check for the state
 
-    async def upload_model(self) -> None:
+    async def _upload_model_return_new_model_uuid(self, context: Context) -> Optional[str]:
         await asyncio.sleep(0.1)  # give tests a bit time to to check for the state
-        await super().upload_model()
-        await asyncio.sleep(0.1)  # give tests a bit time to to check for the state
-
-    async def _upload_model_return_new_id(self, context: Context) -> Optional[str]:
-        await asyncio.sleep(0.1)  # give tests a bit time to to check for the state
-        result = await super()._upload_model_return_new_id(context)
+        result = await super()._upload_model_return_new_model_uuid(context)
         await asyncio.sleep(0.1)  # give tests a bit time to to check for the state
         assert isinstance(result, str)
         return result
 
-    def get_latest_model_files(self) -> Union[List[str], Dict[str, List[str]]]:
+    async def _get_latest_model_files(self) -> Dict[str, List[str]]:
         time.sleep(1)  # NOTE reduce flakyness in Backend tests du to wrong order of events.
         fake_weight_file = '/tmp/weightfile.weights'
         with open(fake_weight_file, 'wb') as f:
@@ -82,18 +77,18 @@ class TestingTrainerLogic(TrainerLogic):
             f.write('zweiundvierzig')
         return {'mocked': [fake_weight_file, more_data_file], 'mocked_2': [fake_weight_file, more_data_file]}
 
-    def can_resume(self) -> bool:
-        return self._can_resume
+    def _can_resume(self) -> bool:
+        return self._can_resume_flag
 
-    async def resume(self) -> None:
-        return await self.start_training()
+    async def _resume(self) -> None:
+        return await self._start_training_from_base_model()
 
     async def _detect(self, model_information: ModelInformation, images:  List[str], model_folder: str) -> List[Detections]:
         detections: List[Detections] = []
         return detections
 
-    async def clear_training_data(self, training_folder: str) -> None:
+    async def _clear_training_data(self, training_folder: str) -> None:
         return
 
-    def get_executor_error_from_log(self) -> Optional[str]:
+    def _get_executor_error_from_log(self) -> Optional[str]:
         return self.error_msg