learning-loop-node 0.11.1__py3-none-any.whl → 0.12.1__py3-none-any.whl

learning_loop_node/data_classes/__init__.py

@@ -5,8 +5,8 @@ from .general import (AnnotationNodeStatus, Category, CategoryType, Context, Det
                       ModelInformation, NodeState, NodeStatus)
 from .image_metadata import ImageMetadata
 from .socket_response import SocketResponse
-from .training import (Errors, Hyperparameter, Model, PretrainedModel, TrainerState, Training, TrainingData,
-                       TrainingError, TrainingOut, TrainingStateData, TrainingStatus)
+from .training import (Errors, PretrainedModel, TrainerState, Training, TrainingError, TrainingOut, TrainingStateData,
+                       TrainingStatus)
 
 __all__ = [
     'AnnotationData', 'AnnotationEventType', 'SegmentationAnnotation', 'ToolOutput', 'UserInput',
@@ -15,6 +15,6 @@ __all__ = [
     'AnnotationNodeStatus', 'Category', 'CategoryType', 'Context', 'DetectionStatus', 'ErrorConfiguration',
     'ModelInformation', 'NodeState', 'NodeStatus',
     'SocketResponse',
-    'Errors', 'Hyperparameter', 'Model', 'PretrainedModel', 'TrainerState', 'Training', 'TrainingData',
+    'Errors', 'PretrainedModel', 'TrainerState', 'Training',
     'TrainingError', 'TrainingOut', 'TrainingStateData', 'TrainingStatus',
 ]

learning_loop_node/data_classes/general.py

@@ -75,7 +75,7 @@ class ModelInformation():
         """
         model_info_file_path = f'{model_root_path}/model.json'
         if not os.path.exists(model_info_file_path):
-            logging.warning(f"could not find model information file '{model_info_file_path}'")
+            logging.warning('could not find model information file %s', model_info_file_path)
             return None
         with open(model_info_file_path, 'r') as f:
             try:

learning_loop_node/data_classes/training.py

@@ -4,46 +4,16 @@ import time
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
 
+from ..helpers.misc import create_image_folder, create_training_folder
 # pylint: disable=no-name-in-module
 from .general import Category, Context
 
 KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
 
 
-@dataclass(**KWONLY_SLOTS)
-class Hyperparameter():
-    resolution: int
-    flip_rl: bool
-    flip_ud: bool
-
-    @staticmethod
-    def from_data(data: Dict):
-        return Hyperparameter(
-            resolution=data['resolution'],
-            flip_rl=data.get('flip_rl', False),
-            flip_ud=data.get('flip_ud', False)
-        )
-
-
-@dataclass(**KWONLY_SLOTS)
-class TrainingData():
-    image_data: List[Dict] = field(default_factory=list)
-    skipped_image_count: Optional[int] = 0
-    categories: List[Category] = field(default_factory=list)
-    hyperparameter: Optional[Hyperparameter] = None
-
-    def image_ids(self):
-        return [image['id'] for image in self.image_data]
-
-    def train_image_count(self):
-        return len([image for image in self.image_data if image['set'] == 'train'])
-
-    def test_image_count(self):
-        return len([image for image in self.image_data if image['set'] == 'test'])
-
-
 @dataclass(**KWONLY_SLOTS)
 class PretrainedModel():
     name: str
@@ -75,26 +45,21 @@ class TrainerState(str, Enum):
 class TrainingStatus():
     id: str  # NOTE this must not be changed, but tests wont detect a change -> update tests!
     name: str
+
     state: Optional[str]
-    errors: Optional[Dict]
     uptime: Optional[float]
+    errors: Optional[Dict[str, Any]]
     progress: Optional[float]
 
-    train_image_count: Optional[int] = None
-    test_image_count: Optional[int] = None
-    skipped_image_count: Optional[int] = None
     pretrained_models: List[PretrainedModel] = field(default_factory=list)
-    hyperparameters: Optional[Dict] = None
     architecture: Optional[str] = None
     context: Optional[Context] = None
 
     def short_str(self) -> str:
         prgr = f'{self.progress * 100:.0f}%' if self.progress else ''
-        trtesk = f'{self.train_image_count}/{self.test_image_count}/{self.skipped_image_count}' if self.train_image_count else 'n.a.'
         cntxt = f'{self.context.organization}/{self.context.project}' if self.context else ''
-        hyps = f'({self.hyperparameters})' if self.hyperparameters else ''
         arch = f'.{self.architecture} - ' if self.architecture else ''
-        return f'[{str(self.state).rsplit(".", maxsplit=1)[-1]} {prgr}. {self.name}({self.id}). Tr/Ts/Tsk: {trtesk} {cntxt}{arch}{hyps}]'
+        return f'[{str(self.state).rsplit(".", maxsplit=1)[-1]} {prgr}. {self.name}({self.id}). {cntxt}{arch}]'
 
 
 @dataclass(**KWONLY_SLOTS)
@@ -105,53 +70,83 @@ class Training():
     project_folder: str  # f'{GLOBALS.data_folder}/{context.organization}/{context.project}'
     images_folder: str  # f'{project_folder}/images'
     training_folder: str  # f'{project_folder}/trainings/{trainings_id}'
+
+    categories: List[Category]
+    hyperparameters: dict
+
+    training_number: int
+    training_state: str
+    model_variant: str  # from `provided_pretrained_models->name`
+
     start_time: float = field(default_factory=time.time)
 
-    # model uuid to download (to continue training) | is not a uuid when training from scratch (blank or pt-name from provided_pretrained_models->name)
-    base_model_uuid_or_name: Optional[str] = None
+    base_model_uuid: Optional[str] = None  # model uuid to continue training (is loaded from loop)
 
-    data: Optional[TrainingData] = None
-    training_number: Optional[int] = None
-    training_state: Optional[str] = None
-    model_uuid_for_detecting: Optional[str] = None
-    hyperparameters: Optional[Dict] = None
+    # NOTE: these are set later after the model has been uploaded
+    image_data: Optional[List[dict]] = None
+    skipped_image_count: Optional[int] = None
+    model_uuid_for_detecting: Optional[str] = None  # Model uuid to load from the loop after training and upload
 
     @property
     def training_folder_path(self) -> Path:
         return Path(self.training_folder)
 
-    def set_values_from_data(self, data: Dict) -> None:
-        self.data = TrainingData(categories=Category.from_list(data['categories']))
-        self.data.hyperparameter = Hyperparameter.from_data(data=data)
-        self.training_number = data['training_number']
-        self.base_model_uuid_or_name = data['id']
-        self.training_state = TrainerState.Initialized
+    @classmethod
+    def generate_training(cls, project_folder: str, context: Context, data: Dict[str, Any]) -> 'Training':
+        if 'hyperparameters' not in data or not isinstance(data['hyperparameters'], dict):
+            raise ValueError('hyperparameters missing or not a dict')
+        if 'categories' not in data or not isinstance(data['categories'], list):
+            raise ValueError('categories missing or not a list')
+        if 'training_number' not in data or not isinstance(data['training_number'], int):
+            raise ValueError('training_number missing or not an int')
+        if 'model_variant' not in data or not isinstance(data['model_variant'], str):
+            raise ValueError('model_variant missing or not a str')
+
+        training_uuid = str(uuid4())
+
+        return Training(
+            id=training_uuid,
+            context=context,
+            project_folder=project_folder,
+            images_folder=create_image_folder(project_folder),
+            training_folder=create_training_folder(project_folder, training_uuid),
+            categories=Category.from_list(data['categories']),
+            hyperparameters=data['hyperparameters'],
+            training_number=data['training_number'],
+            base_model_uuid=data.get('base_model_uuid', None),
+            model_variant=data['model_variant'],
+            training_state=TrainerState.Initialized.value
+        )
+
+    def image_ids(self) -> List[str]:
+        assert self.image_data is not None, 'Image data not set'
+        return [image['id'] for image in self.image_data]
+
+    def train_image_count(self) -> int:
+        assert self.image_data is not None, 'Image data not set'
+        return len([image for image in self.image_data if image['set'] == 'train'])
+
+    def test_image_count(self) -> int:
+        assert self.image_data is not None, 'Image data not set'
+        return len([image for image in self.image_data if image['set'] == 'test'])
 
 
 @dataclass(**KWONLY_SLOTS)
 class TrainingOut():
+    trainer_id: str
+    trainer_name: Optional[str] = None
     confusion_matrix: Optional[Dict] = None  # This is actually just class-wise metrics
     train_image_count: Optional[int] = None
     test_image_count: Optional[int] = None
-    trainer_id: Optional[str] = None
-    hyperparameters: Optional[Dict] = None
+    hyperparameters: Optional[Dict[str, Any]] = None
+    best_epoch: Optional[int] = None
 
 
 @dataclass(**KWONLY_SLOTS)
 class TrainingStateData():
     confusion_matrix: Dict = field(default_factory=dict)
     meta_information: Dict = field(default_factory=dict)
-
-
-@dataclass(**KWONLY_SLOTS)
-class Model():
-    uuid: str
-    confusion_matrix: Optional[Dict] = None
-    parent_id: Optional[str] = None
-    train_image_count: Optional[int] = None
-    test_image_count: Optional[int] = None
-    trainer_id: Optional[str] = None
-    hyperparameters: Optional[str] = None
+    epoch: Optional[int] = None
 
 
 class Errors():

learning_loop_node/data_exchanger.py

@@ -62,7 +62,7 @@ class DataExchanger():
 
     async def fetch_image_uuids(self, query_params: Optional[str] = '') -> List[str]:
         """Fetch image uuids from the learning loop data endpoint."""
-        logging.info(f'Fetching image uuids for {self.context.organization}/{self.context.project}..')
+        logging.info('Fetching image uuids for %s/%s..', self.context.organization, self.context.project)
 
         response = await self.loop_communicator.get(f'/{self.context.organization}/projects/{self.context.project}/data?{query_params}')
         assert response.status_code == 200, response
@@ -70,7 +70,7 @@ class DataExchanger():
 
     async def download_images_data(self, image_uuids: List[str], chunk_size: int = 100) -> List[Dict]:
         """Download image annotations, tags, set and other information for the given image uuids."""
-        logging.info(f'Fetching annotations, tags, sets, etc. for {len(image_uuids)} images..')
+        logging.info('Fetching annotations, tags, sets, etc. for %s images..', len(image_uuids))
 
         num_image_ids = len(image_uuids)
         if num_image_ids == 0:
@@ -84,7 +84,7 @@ class DataExchanger():
             chunk_ids = image_uuids[i:i+chunk_size]
             response = await self.loop_communicator.get(f'/{self.context.organization}/projects/{self.context.project}/images?ids={",".join(chunk_ids)}')
             if response.status_code != 200:
-                logging.error(f'Error {response.status_code} during downloading image data. Continue with next batch..')
+                logging.error('Error %s during downloading image data. Continue with next batch..', response.status_code)
                 continue
             images_data += response.json()['images']
 
@@ -92,7 +92,7 @@ class DataExchanger():
 
     async def download_images(self, image_uuids: List[str], image_folder: str, chunk_size: int = 10) -> None:
         """Downloads images (actual image data). Will skip existing images"""
-        logging.info(f'Downloading {len(image_uuids)} images (actual image data).. skipping existing images.')
+        logging.info('Downloading %s images (actual image data).. skipping existing images.', len(image_uuids))
         if not image_uuids:
             return
 
@@ -106,7 +106,7 @@ class DataExchanger():
             self.progress = 1.0
             return
 
-        logging.info(f'Downloading {num_new_image_ids} new images to {image_folder}..')
+        logging.info('Downloading %s new images to %s..', num_new_image_ids, image_folder)
         os.makedirs(image_folder, exist_ok=True)
 
         progress_factor = 0.5 / num_new_image_ids  # second 50% of progress is for downloading images
@@ -124,11 +124,8 @@ class DataExchanger():
 
     async def _download_one_image(self, path: str, image_id: str, image_folder: str) -> None:
         response = await self.loop_communicator.get(path)
-        if response.status_code == 429:
-            await asyncio.sleep(1)
-            response = await self.loop_communicator.get(path)
         if response.status_code != HTTPStatus.OK:
-            logging.error(f'bad status code {response.status_code} for {path}. Details: {response.text}')
+            logging.error('bad status code %s for %s. Details: %s', response.status_code, path, response.text)
             return
         filename = f'{image_folder}/{image_id}.jpg'
         async with aiofiles.open(filename, 'wb') as f:
@@ -171,7 +168,7 @@ class DataExchanger():
             created_files.append(new_file)
 
         shutil.rmtree(tmp_path, ignore_errors=True)
-        logging.info(f'Downloaded model {model_uuid}({model_format}) to {target_folder}.')
+        logging.info('Downloaded model %s(%s) to %s.', model_uuid, model_format, target_folder)
         return created_files
 
     async def upload_model_get_uuid(self, context: Context, files: List[str], training_number: Optional[int], mformat: str) -> str:
@@ -182,10 +179,12 @@ class DataExchanger():
         """
         response = await self.loop_communicator.put(f'/{context.organization}/projects/{context.project}/trainings/{training_number}/models/latest/{mformat}/file', files=files)
         if response.status_code != 200:
-            logging.error(f'Could not upload model for training {training_number}, format {mformat}: {response.text}')
+            logging.error('Could not upload model for training %s, format %s: %s',
+                          training_number, mformat, response.text)
             raise CriticalError(
                 f'Could not upload model for training {training_number}, format {mformat}: {response.text}')
 
         uploaded_model = response.json()
-        logging.info(f'Uploaded model for training {training_number}, format {mformat}. Response is: {uploaded_model}')
+        logging.info('Uploaded model for training %s, format %s. Response is: %s',
+                     training_number, mformat, uploaded_model)
         return uploaded_model['id']

learning_loop_node/helpers/environment_reader.py

@@ -11,14 +11,14 @@ def read_from_env(possible_names: List[str], ignore_errors: bool = True) -> Opti
     # Possible error: no values are set
     if not values:
         if ignore_errors:
-            logging.warning(f'no environment variable set for {possible_names}')
+            logging.warning('no environment variable set for %s', possible_names)
             return None
         raise ValueError(f'no environment variable set for {possible_names}')
 
     # Possible error: multiple values are not None and not equal
     if len(values) > 1 and len(set(values)) > 1:
         if ignore_errors:
-            logging.warning(f'different environment variables set for {possible_names}: {values}')
+            logging.warning('different environment variables set for %s: %s', possible_names, values)
             return None
         raise ValueError(f'different environment variables set for {possible_names}: {values}')
 

learning_loop_node/helpers/log_conf.py

@@ -2,7 +2,7 @@ import logging.config
 
 LOGGING_CONF = {
     'version': 1,
-    'disable_existing_loggers': True,  # to make sure this config is used
+    'disable_existing_loggers': False,  # to make sure this config is used
     'formatters': {
         'default': {
             'format': '%(asctime)s,%(msecs)01d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s',
@@ -34,3 +34,6 @@ LOGGING_CONF = {
 
 def init():
     logging.config.dictConfig(LOGGING_CONF)
+
+
+init()

learning_loop_node/helpers/misc.py

@@ -14,7 +14,8 @@ from uuid import UUID, uuid4
 
 import pynvml
 
-from ..data_classes import Context, SocketResponse, Training
+from ..data_classes.general import Context
+from ..data_classes.socket_response import SocketResponse
 from ..globals import GLOBALS
 
 T = TypeVar('T')
@@ -81,11 +82,11 @@ async def delete_corrupt_images(image_folder: str, check_jpeg: bool = False) ->
     n_deleted = 0
     for image in glob(f'{image_folder}/*.jpg'):
         if not await is_valid_image(image, check_jpeg):
-            logging.debug(f'  deleting image {image}')
+            logging.debug('  deleting image %s', image)
             os.remove(image)
             n_deleted += 1
 
-    logging.info(f'deleted {n_deleted} images')
+    logging.info('deleted %s images', n_deleted)
 
 
 def create_resource_paths(organization_name: str, project_name: str, image_ids: List[str]) -> Tuple[List[str], List[str]]:
@@ -144,7 +145,7 @@ def ensure_socket_response(func):
             raise Exception(
                 f"Return type for sio must be str, bool, SocketResponse or None', but was {type(value)}'")
         except Exception as e:
-            logging.exception(f'An error occured for {args[0]}')
+            logging.exception('An error occured for %s', args[0])
 
             return asdict(SocketResponse.for_failure(str(e)))
 
@@ -183,26 +184,15 @@ def activate_asyncio_warnings() -> None:
 
 
 def images_for_ids(image_ids, image_folder) -> List[str]:
-    logging.info(f'### Going to get images for {len(image_ids)} images ids')
+    logging.info('### Going to get images for %s images ids', len(image_ids))
     start = perf_counter()
     images = [img for img in glob(f'{image_folder}/**/*.*', recursive=True)
               if os.path.splitext(os.path.basename(img))[0] in image_ids]
     end = perf_counter()
-    logging.info(f'found {len(images)} images for {len(image_ids)} image ids, which took {end-start:0.2f} seconds')
+    logging.info('found %s images for %s image ids, which took %.2f seconds', len(images), len(image_ids), end-start)
     return images
 
 
-def generate_training(project_folder: str, context: Context) -> Training:
-    training_uuid = str(uuid4())
-    return Training(
-        id=training_uuid,
-        context=context,
-        project_folder=project_folder,
-        images_folder=create_image_folder(project_folder),
-        training_folder=create_training_folder(project_folder, training_uuid)
-    )
-
-
 def delete_all_training_folders(project_folder: str):
     if not os.path.exists(f'{project_folder}/trainings'):
         return

learning_loop_node/loop_communication.py

@@ -10,6 +10,23 @@ from .helpers import environment_reader
 
 logging.basicConfig(level=logging.INFO)
 
+SLEEP_TIME_ON_429 = 5
+MAX_RETRIES_ON_429 = 20
+
+
+def retry_on_429(func: Callable[..., Awaitable]) -> Callable[..., Awaitable]:
+    """Decorator that retries requests that receive a 429 status code."""
+    async def wrapper(*args, **kwargs) -> httpx.Response:
+        for _ in range(MAX_RETRIES_ON_429):
+            response = await func(*args, **kwargs)
+            if response.status_code != 429:
+                return response
+
+            await asyncio.sleep(SLEEP_TIME_ON_429)
+
+        return response
+    return wrapper
+
 
 class LoopCommunicationException(Exception):
     """Raised when there's an unexpected answer from the learning loop."""
@@ -94,9 +111,9 @@ class LoopCommunicator():
         if requires_login:
             await self.ensure_login()
             return await self.retry_on_401(self._get, path, api_prefix)
-        else:
-            return await self._get(path, api_prefix)
+        return await self._get(path, api_prefix)
 
+    @retry_on_429
     async def _get(self, path: str, api_prefix: str) -> httpx.Response:
         return await self.async_client.get(api_prefix+path)
 
@@ -104,9 +121,9 @@ class LoopCommunicator():
         if requires_login:
             await self.ensure_login()
             return await self.retry_on_401(self._put, path, files, api_prefix, **kwargs)
-        else:
-            return await self._put(path, files, api_prefix, **kwargs)
+        return await self._put(path, files, api_prefix, **kwargs)
 
+    @retry_on_429
     async def _put(self, path: str, files: Optional[List[str]], api_prefix: str, **kwargs) -> httpx.Response:
         if files is None:
             return await self.async_client.put(api_prefix+path, **kwargs)
@@ -133,9 +150,9 @@ class LoopCommunicator():
         if requires_login:
             await self.ensure_login()
             return await self.retry_on_401(self._post, path, api_prefix, **kwargs)
-        else:
-            return await self._post(path, api_prefix, **kwargs)
+        return await self._post(path, api_prefix, **kwargs)
 
+    @retry_on_429
     async def _post(self, path, api_prefix='/api', **kwargs) -> httpx.Response:
         return await self.async_client.post(api_prefix+path, **kwargs)
 
@@ -143,8 +160,8 @@ class LoopCommunicator():
         if requires_login:
             await self.ensure_login()
             return await self.retry_on_401(self._delete, path, api_prefix, **kwargs)
-        else:
-            return await self._delete(path, api_prefix, **kwargs)
+        return await self._delete(path, api_prefix, **kwargs)
 
+    @retry_on_429
     async def _delete(self, path, api_prefix, **kwargs) -> httpx.Response:
         return await self.async_client.delete(api_prefix+path, **kwargs)

learning_loop_node/node.py

@@ -1,3 +1,10 @@
+
+# NOTE: log_conf is imported first to initialize the loggers before they are created
+from .helpers import log_conf  # pylint: disable=unused-import
+
+# isort: split
+# pylint: disable=wrong-import-order,ungrouped-imports
+
 import asyncio
 import logging
 import ssl
@@ -14,7 +21,6 @@ from socketio import AsyncClient
 
 from .data_classes import NodeStatus
 from .data_exchanger import DataExchanger
-from .helpers import log_conf
 from .helpers.misc import ensure_socket_response, read_or_create_uuid
 from .loop_communication import LoopCommunicator
 from .rest import router
@@ -39,7 +45,6 @@ class Node(FastAPI):
         """
 
         super().__init__(lifespan=self.lifespan)
-        log_conf.init()
 
         self.name = name
         self.uuid = uuid or read_or_create_uuid(self.name)
@@ -98,13 +103,14 @@ class Node(FastAPI):
                     pass
 
     async def _on_startup(self):
-        self.log.info('received "startup" lifecycle-event')
+        self.log.info('received "startup" lifecycle-event - connecting to loop')
         try:
             await self.reconnect_to_loop()
         except Exception:
             self.log.warning('Could not establish sio connection to loop during startup')
-        self.log.info('done')
+        self.log.info('successfully connected to loop - calling on_startup')
         await self.on_startup()
+        self.log.info('successfully finished on_startup')
 
     async def _on_shutdown(self):
         self.log.info('received "shutdown" lifecycle-event')

learning_loop_node/rest.py

@@ -1,4 +1,5 @@
 import logging
+from logging import Logger
 from typing import TYPE_CHECKING
 
 from fastapi import APIRouter, HTTPException, Request
@@ -20,14 +21,15 @@ async def _debug_logging(request: Request) -> str:
     '''
     state = str(await request.body(), 'utf-8')
     node: 'Node' = request.app
+    log: Logger = node.log  # type: ignore
 
     if state == 'off':
         logger.info('turning debug logging off')
-        node.log.setLevel('INFO')
+        log.setLevel('INFO')
         return 'off'
     if state == 'on':
         logger.info('turning debug logging on')
-        node.log.setLevel('DEBUG')
+        log.setLevel('DEBUG')
         return 'on'
     raise HTTPException(status_code=400, detail='Invalid state')
 

learning_loop_node/tests/detector/conftest.py

@@ -118,34 +118,30 @@ def get_outbox_files(outbox: Outbox):
     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.image_metadata = ImageMetadata(
-                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
+class MockDetectorLogic(DetectorLogic):  # pylint: disable=abstract-method
+    def __init__(self):
+        super().__init__('mock')
+        self.image_metadata = ImageMetadata(
+            box_detections=[BoxDetection(category_name="test",
+                                         category_id="1",
+                                         confidence=0.9,
+                                         x=0, y=0, width=10, height=10,
+                                         model_name="mock",
+                                         )])
 
-        def evaluate_with_all_info(self, image: np.ndarray, tags: List[str], source: Optional[str] = None, creation_date: Optional[str] = None):
-            return self.image_metadata
+    @property
+    def is_initialized(self):
+        return True
 
-    return MockDetectorLogic()
+    def evaluate_with_all_info(self, image: np.ndarray, tags: List[str], source: Optional[str] = None, creation_date: Optional[str] = None):
+        return self.image_metadata
 
 
 @pytest.fixture
-def detector_node(mock_detector_logic):
+def detector_node():
     os.environ['LOOP_ORGANIZATION'] = 'test_organization'
     os.environ['LOOP_PROJECT'] = 'test_project'
-    return DetectorNode(name="test_node", detector=mock_detector_logic)
+    return DetectorNode(name="test_node", detector=MockDetectorLogic())
 
 # ====================================== REDUNDANT FIXTURES IN ALL CONFTESTS ! ======================================
 

learning_loop_node/tests/trainer/conftest.py

@@ -30,12 +30,15 @@ async def test_initialized_trainer_node():
     node = TrainerNode(name='test', trainer_logic=trainer, uuid='NOD30000-0000-0000-0000-000000000000')
     trainer._node = node
     trainer._init_new_training(context=Context(organization='zauberzeug', project='demo'),
-                               details={'categories': [],
-                                        'id': '00000000-0000-0000-0000-000000000012',  # version 1.2 of demo project
-                                        'training_number': 0,
-                                        'resolution': 800,
-                                        'flip_rl': False,
-                                        'flip_ud': False})
+                               training_config={'categories': [],
+                                                'id': '00000000-0000-0000-0000-000000000012',  # version 1.2 of demo project
+                                                'training_number': 0,
+                                                'model_variant': '',
+                                                'hyperparameters': {
+                                   'resolution': 800,
+                                   'flip_rl': False,
+                                   'flip_ud': False}
+    })
     await node._on_startup()
     yield node
     await node._on_shutdown()
@@ -50,12 +53,15 @@ async def test_initialized_trainer():
     await node._on_startup()
     trainer._node = node
     trainer._init_new_training(context=Context(organization='zauberzeug', project='demo'),
-                               details={'categories': [],
-                                        'id': '00000000-0000-0000-0000-000000000012',  # version 1.2 of demo project
-                                        'training_number': 0,
-                                        'resolution': 800,
-                                        'flip_rl': False,
-                                        'flip_ud': False})
+                               training_config={'categories': [],
+                                                'id': '00000000-0000-0000-0000-000000000012',  # version 1.2 of demo project
+                                                'training_number': 0,
+                                                'model_variant': '',
+                                                'hyperparameters': {
+                                   'resolution': 800,
+                                   'flip_rl': False,
+                                   'flip_ud': False}
+    })
     yield trainer
     try:
         await node._on_shutdown()