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

learning_loop_node/annotation/annotator_node.py

@@ -73,7 +73,8 @@ class AnnotatorNode(Node):
             capabilities=['segmentation']
         )
 
-        self.log.debug('Sending status %s', status)
+        self.log_status_on_change(status.state.value if status.state else 'None', status)
+
         try:
             result = await self.sio_client.call('update_annotation_node', jsonable_encoder(asdict(status)), timeout=10)
         except Exception:

learning_loop_node/data_classes/__init__.py

@@ -1,20 +1,19 @@
-from .annotations import AnnotationData, AnnotationEventType, SegmentationAnnotation, ToolOutput, UserInput
+from .annotations import AnnotationData, SegmentationAnnotation, ToolOutput, UserInput
 from .detections import (BoxDetection, ClassificationDetection, Detections, Observation, Point, PointDetection,
                          SegmentationDetection, Shape)
-from .general import (AnnotationNodeStatus, Category, CategoryType, Context, DetectionStatus, ErrorConfiguration,
-                      ModelInformation, NodeState, NodeStatus)
+from .general import (AboutResponse, AnnotationNodeStatus, Category, Context, DetectionStatus, ErrorConfiguration,
+                      ModelInformation, ModelVersionResponse, NodeState, NodeStatus)
 from .image_metadata import ImageMetadata
 from .socket_response import SocketResponse
-from .training import (Errors, PretrainedModel, TrainerState, Training, TrainingError, TrainingOut, TrainingStateData,
-                       TrainingStatus)
+from .training import Errors, PretrainedModel, Training, TrainingError, TrainingOut, TrainingStateData, TrainingStatus
 
 __all__ = [
-    'AnnotationData', 'AnnotationEventType', 'SegmentationAnnotation', 'ToolOutput', 'UserInput',
+    'AboutResponse', 'AnnotationData', 'SegmentationAnnotation', 'ToolOutput', 'UserInput',
     'BoxDetection', 'ClassificationDetection', 'ImageMetadata', 'Observation', 'Point', 'PointDetection',
     'SegmentationDetection', 'Shape', 'Detections',
-    'AnnotationNodeStatus', 'Category', 'CategoryType', 'Context', 'DetectionStatus', 'ErrorConfiguration',
-    'ModelInformation', 'NodeState', 'NodeStatus',
+    'AnnotationNodeStatus', 'Category', 'Context', 'DetectionStatus', 'ErrorConfiguration',
+    'ModelInformation', 'NodeState', 'NodeStatus', 'ModelVersionResponse',
     'SocketResponse',
-    'Errors', 'PretrainedModel', 'TrainerState', 'Training',
+    'Errors', 'PretrainedModel', 'Training',
     'TrainingError', 'TrainingOut', 'TrainingStateData', 'TrainingStatus',
 ]

learning_loop_node/data_classes/annotations.py

@@ -1,24 +1,14 @@
 import sys
 from dataclasses import dataclass
-from enum import Enum
 from typing import Optional, Union
 
+from ..enums import AnnotationEventType
 from .detections import Point, Shape
 from .general import Category, Context
 
 KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
 
 
-class AnnotationEventType(str, Enum):
-    LeftMouseDown = 'left_mouse_down'
-    RightMouseDown = 'right_mouse_down'
-    MouseMove = 'mouse_move'
-    LeftMouseUp = 'left_mouse_up'
-    RightMouseUp = 'right_mouse_up'
-    KeyUp = 'key_up'
-    KeyDown = 'key_down'
-
-
 @dataclass(**KWONLY_SLOTS)
 class AnnotationData():
     coordinate: Point

learning_loop_node/data_classes/general.py

@@ -8,14 +8,9 @@ from typing import Dict, List, Optional, Union
 
 from dacite import from_dict
 
-KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
-
+from ..enums import CategoryType
 
-class CategoryType(str, Enum):
-    Box = 'box'
-    Point = 'point'
-    Segmentation = 'segmentation'
-    Classification = 'classification'
+KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
 
 
 @dataclass(**KWONLY_SLOTS)
@@ -104,6 +99,29 @@ class ModelInformation():
         return from_dict(ModelInformation, data=data)
 
 
+@dataclass(**KWONLY_SLOTS)
+class AboutResponse:
+    operation_mode: str = field(metadata={"description": "The operation mode of the detector node"})
+    state: Optional[str] = field(metadata={
+        "description": "The state of the detector node",
+        "example": "idle, online, detecting"})
+    model_info: Optional[ModelInformation] = field(metadata={
+        "description": "Information about the model of the detector node"})
+    target_model: Optional[str] = field(metadata={"description": "The target model of the detector node"})
+    version_control: str = field(metadata={
+        "description": "The version control mode of the detector node",
+        "example": "follow_loop, specific_version, pause"})
+
+
+@dataclass(**KWONLY_SLOTS)
+class ModelVersionResponse:
+    current_version: str = field(metadata={"description": "The version of the model currently used by the detector."})
+    target_version: str = field(metadata={"description": "The target model version set in the detector."})
+    loop_version: str = field(metadata={"description": "The target model version specified by the loop."})
+    local_versions: List[str] = field(metadata={"description": "The locally available versions of the model."})
+    version_control: str = field(metadata={"description": "The version control mode."})
+
+
 @dataclass(**KWONLY_SLOTS)
 class ErrorConfiguration():
     begin_training: Optional[bool] = False

learning_loop_node/data_classes/training.py

@@ -2,11 +2,11 @@
 import sys
 import time
 from dataclasses import dataclass, field
-from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
+from ..enums import TrainerState
 from ..helpers.misc import create_image_folder, create_training_folder
 # pylint: disable=no-name-in-module
 from .general import Category, Context
@@ -21,26 +21,6 @@ class PretrainedModel():
     description: str
 
 
-class TrainerState(str, Enum):
-    Idle = 'idle'
-    Initialized = 'initialized'
-    Preparing = 'preparing'
-    DataDownloading = 'data_downloading'
-    DataDownloaded = 'data_downloaded'
-    TrainModelDownloading = 'train_model_downloading'
-    TrainModelDownloaded = 'train_model_downloaded'
-    TrainingRunning = 'running'
-    TrainingFinished = 'training_finished'
-    ConfusionMatrixSyncing = 'confusion_matrix_syncing'
-    ConfusionMatrixSynced = 'confusion_matrix_synced'
-    TrainModelUploading = 'train_model_uploading'
-    TrainModelUploaded = 'train_model_uploaded'
-    Detecting = 'detecting'
-    Detected = 'detected'
-    DetectionUploading = 'detection_uploading'
-    ReadyForCleanup = 'ready_for_cleanup'
-
-
 @dataclass(**KWONLY_SLOTS)
 class TrainingStatus():
     id: str  # NOTE this must not be changed, but tests wont detect a change -> update tests!

learning_loop_node/detector/detector_logic.py

@@ -31,14 +31,15 @@ class DetectorLogic():
         logging.info('Loading model from %s', GLOBALS.data_folder)
         model_info = ModelInformation.load_from_disk(f'{GLOBALS.data_folder}/model')
         if model_info is None:
-            logging.warning('No model found')
+            logging.error('No model found')
             self._model_info = None
-            return
+            raise Exception('No model found')
         try:
             self._model_info = model_info
             self.init()
             logging.info('Successfully loaded model %s', self._model_info)
         except Exception:
+            self._model_info = None
             logging.error('Could not init model %s', model_info)
             raise
 

learning_loop_node/detector/detector_node.py

@@ -6,7 +6,7 @@ import subprocess
 from dataclasses import asdict
 from datetime import datetime
 from threading import Thread
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
 import numpy as np
 import socketio
@@ -14,9 +14,11 @@ from dacite import from_dict
 from fastapi.encoders import jsonable_encoder
 from socketio import AsyncClient
 
-from ..data_classes import Category, Context, DetectionStatus, ImageMetadata, ModelInformation, Shape
+from ..data_classes import (AboutResponse, Category, Context, DetectionStatus, ImageMetadata, ModelInformation,
+                            ModelVersionResponse, Shape)
 from ..data_classes.socket_response import SocketResponse
 from ..data_exchanger import DataExchanger, DownloadError
+from ..enums import OperationMode, VersionMode
 from ..globals import GLOBALS
 from ..helpers import environment_reader
 from ..node import Node
@@ -30,7 +32,6 @@ from .rest import model_version_control as rest_version_control
 from .rest import operation_mode as rest_mode
 from .rest import outbox_mode as rest_outbox_mode
 from .rest import upload as rest_upload
-from .rest.operation_mode import OperationMode
 
 
 class DetectorNode(Node):
@@ -58,8 +59,8 @@ class DetectorNode(Node):
         # FollowLoop: the detector node will follow the loop and update the model if necessary
         # SpecificVersion: the detector node will update to a specific version, set via the /model_version endpoint
         # Pause: the detector node will not update the model
-        self.version_control: rest_version_control.VersionMode = rest_version_control.VersionMode.Pause if os.environ.get(
-            'VERSION_CONTROL_DEFAULT', 'follow_loop').lower() == 'pause' else rest_version_control.VersionMode.FollowLoop
+        self.version_control: VersionMode = VersionMode.Pause if os.environ.get(
+            'VERSION_CONTROL_DEFAULT', 'follow_loop').lower() == 'pause' else VersionMode.FollowLoop
         self.target_model: Optional[ModelInformation] = None
         self.loop_deployment_target: Optional[ModelInformation] = None
 
@@ -75,6 +76,76 @@ class DetectorNode(Node):
 
         self.setup_sio_server()
 
+    def get_about_response(self) -> AboutResponse:
+        return AboutResponse(
+            operation_mode=self.operation_mode.value,
+            state=self.status.state,
+            model_info=self.detector_logic._model_info,  # pylint: disable=protected-access
+            target_model=self.target_model.version if self.target_model else None,
+            version_control=self.version_control.value
+        )
+
+    def get_model_version_response(self) -> ModelVersionResponse:
+        current_version = self.detector_logic._model_info.version if self.detector_logic._model_info is not None else 'None'  # pylint: disable=protected-access
+        target_version = self.target_model.version if self.target_model is not None else 'None'
+        loop_version = self.loop_deployment_target.version if self.loop_deployment_target is not None else 'None'
+
+        local_versions: list[str] = []
+        models_path = os.path.join(GLOBALS.data_folder, 'models')
+        local_models = os.listdir(models_path) if os.path.exists(models_path) else []
+        for model in local_models:
+            if model.replace('.', '').isdigit():
+                local_versions.append(model)
+
+        return ModelVersionResponse(
+            current_version=current_version,
+            target_version=target_version,
+            loop_version=loop_version,
+            local_versions=local_versions,
+            version_control=self.version_control.value,
+        )
+
+    async def set_model_version_mode(self, version_control_mode: str) -> None:
+
+        self.log.info('Setting model version mode to %s', version_control_mode)
+
+        if version_control_mode == 'follow_loop':
+            self.version_control = VersionMode.FollowLoop
+        elif version_control_mode == 'pause':
+            self.version_control = VersionMode.Pause
+        else:
+            self.version_control = VersionMode.SpecificVersion
+            if not version_control_mode or not version_control_mode.replace('.', '').isdigit():
+                raise Exception('Invalid version number')
+            target_version = version_control_mode
+
+            if self.target_model is not None and self.target_model.version == target_version:
+                return
+
+            # Fetch the model uuid by version from the loop
+            uri = f'/{self.organization}/projects/{self.project}/models'
+            response = await self.loop_communicator.get(uri)
+            if response.status_code != 200:
+                self.version_control = VersionMode.Pause
+                raise Exception('Failed to load models from learning loop')
+
+            models = response.json()['models']
+            models_with_target_version = [m for m in models if m['version'] == target_version]
+            if len(models_with_target_version) == 0:
+                self.version_control = VersionMode.Pause
+                raise Exception(f'No Model with version {target_version}')
+            if len(models_with_target_version) > 1:
+                self.version_control = VersionMode.Pause
+                raise Exception(f'Multiple models with version {target_version}')
+
+            model_id = models_with_target_version[0]['id']
+            model_host = models_with_target_version[0].get('host', 'unknown')
+
+            self.target_model = ModelInformation(organization=self.organization, project=self.project,
+                                                 host=model_host, categories=[],
+                                                 id=model_id,
+                                                 version=target_version)
+
     async def soft_reload(self) -> None:
         # simulate init
         self.organization = environment_reader.organization()
@@ -85,8 +156,8 @@ class DetectorNode(Node):
             Context(organization=self.organization, project=self.project),
             self.loop_communicator)
         self.relevance_filter = RelevanceFilter(self.outbox)
-        self.version_control = rest_version_control.VersionMode.Pause if os.environ.get(
-            'VERSION_CONTROL_DEFAULT', 'follow_loop').lower() == 'pause' else rest_version_control.VersionMode.FollowLoop
+        self.version_control = VersionMode.Pause if os.environ.get(
+            'VERSION_CONTROL_DEFAULT', 'follow_loop').lower() == 'pause' else VersionMode.FollowLoop
         self.target_model = None
         # self.setup_sio_server()
 
@@ -141,9 +212,8 @@ class DetectorNode(Node):
         @self.sio.event
         async def detect(sid, data: Dict) -> Dict:
             try:
-                np_image = np.frombuffer(data['image'], np.uint8)
                 det = await self.get_detections(
-                    raw_image=np_image,
+                    raw_image=np.frombuffer(data['image'], np.uint8),
                     camera_id=data.get('camera-id', None) or data.get('mac', None),
                     tags=data.get('tags', []),
                     source=data.get('source', None),
@@ -160,10 +230,38 @@ class DetectorNode(Node):
                 return {'error': str(e)}
 
         @self.sio.event
-        async def info(sid) -> Union[str, Dict]:
+        async def info(sid) -> Dict:
             if self.detector_logic.is_initialized:
                 return asdict(self.detector_logic.model_info)
-            return 'No model loaded'
+            return {"status": "No model loaded"}
+
+        @self.sio.event
+        async def about(sid) -> Dict:
+            return asdict(self.get_about_response())
+
+        @self.sio.event
+        async def get_model_version(sid) -> Dict:
+            return asdict(self.get_model_version_response())
+
+        @self.sio.event
+        async def set_model_version_mode(sid, data: str) -> Dict:
+            try:
+                await self.set_model_version_mode(data)
+                return {"status": "OK"}
+            except Exception as e:
+                return {'error': str(e)}
+
+        @self.sio.event
+        async def get_outbox_mode(sid) -> Dict:
+            return {'outbox_mode': self.outbox.get_mode().value}
+
+        @self.sio.event
+        async def set_outbox_mode(sid, data: str) -> Dict:
+            try:
+                await self.outbox.set_mode(data)
+                return {"status": "OK"}
+            except Exception as e:
+                return {'error': str(e)}
 
         @self.sio.event
         async def upload(sid, data: Dict) -> Optional[Dict]:
@@ -228,13 +326,16 @@ class DetectorNode(Node):
                 with step_into(GLOBALS.data_folder):
                     model_symlink = 'model'
                     target_model_folder = f'models/{self.target_model.version}'
-                    shutil.rmtree(target_model_folder, ignore_errors=True)
-                    os.makedirs(target_model_folder)
-
-                    await self.data_exchanger.download_model(target_model_folder,
-                                                             Context(organization=self.organization,
-                                                                     project=self.project),
-                                                             self.target_model.id, self.detector_logic.model_format)
+                    if not os.path.exists(target_model_folder):
+                        os.makedirs(target_model_folder)
+                        await self.data_exchanger.download_model(target_model_folder,
+                                                                 Context(organization=self.organization,
+                                                                         project=self.project),
+                                                                 self.target_model.id,
+                                                                 self.detector_logic.model_format)
+                        self.log.info('Downloaded model %s', self.target_model.version)
+                    else:
+                        self.log.info('No need to download model %s (already exists)', self.target_model.version)
                     try:
                         os.unlink(model_symlink)
                         os.remove(model_symlink)
@@ -243,7 +344,12 @@ class DetectorNode(Node):
                     os.symlink(target_model_folder, model_symlink)
                     self.log.info('Updated symlink for model to %s', os.readlink(model_symlink))
 
-                    self.detector_logic.load_model()
+                    try:
+                        self.detector_logic.load_model()
+                    except Exception:
+                        self.log.exception('Could not load model, will retry download on next check')
+                        shutil.rmtree(target_model_folder, ignore_errors=True)
+                        return
                     try:
                         await self.sync_status_with_learning_loop()
                     except Exception:
@@ -292,7 +398,8 @@ class DetectorNode(Node):
             model_format=self.detector_logic.model_format,
         )
 
-        self.log.debug('sending status %s', status)
+        self.log_status_on_change(status.state or 'None', status)
+
         response = await self.sio_client.call('update_detector', (self.organization, self.project, jsonable_encoder(asdict(status))))
         if not response:
             self.socket_connection_broken = True
@@ -313,7 +420,7 @@ class DetectorNode(Node):
                                                        id=deployment_target_model_id,
                                                        version=deployment_target_model_version)
 
-        if (self.version_control == rest_version_control.VersionMode.FollowLoop and
+        if (self.version_control == VersionMode.FollowLoop and
                 self.target_model != self.loop_deployment_target):
             old_target_model_version = self.target_model.version if self.target_model else None
             self.target_model = self.loop_deployment_target

learning_loop_node/detector/outbox.py

@@ -7,7 +7,6 @@ import shutil
 from asyncio import Task
 from dataclasses import asdict
 from datetime import datetime
-from enum import Enum
 from glob import glob
 from io import BufferedReader, TextIOWrapper
 from multiprocessing import Event
@@ -20,15 +19,11 @@ import PIL.Image  # type: ignore
 from fastapi.encoders import jsonable_encoder
 
 from ..data_classes import ImageMetadata
+from ..enums import OutboxMode
 from ..globals import GLOBALS
 from ..helpers import environment_reader
 
 
-class OutboxMode(Enum):
-    CONTINUOUS_UPLOAD = 'continuous_upload'
-    STOPPED = 'stopped'
-
-
 class Outbox():
     def __init__(self) -> None:
         self.log = logging.getLogger()

learning_loop_node/detector/rest/about.py

@@ -1,11 +1,10 @@
 
 import sys
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from fastapi import APIRouter, Request
 
-from ...data_classes import ModelInformation
+from ...data_classes import AboutResponse
 
 if TYPE_CHECKING:
     from ..detector_node import DetectorNode
@@ -14,20 +13,6 @@ KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) e
 router = APIRouter()
 
 
-@dataclass(**KWONLY_SLOTS)
-class AboutResponse:
-    operation_mode: str = field(metadata={"description": "The operation mode of the detector node"})
-    state: Optional[str] = field(metadata={
-        "description": "The state of the detector node",
-        "example": "idle, online, detecting"})
-    model_info: Optional[ModelInformation] = field(metadata={
-        "description": "Information about the model of the detector node"})
-    target_model: Optional[str] = field(metadata={"description": "The target model of the detector node"})
-    version_control: str = field(metadata={
-        "description": "The version control mode of the detector node",
-        "example": "follow_loop, specific_version, pause"})
-
-
 @router.get("/about", response_model=AboutResponse)
 async def get_about(request: Request):
     '''
@@ -38,13 +23,4 @@ async def get_about(request: Request):
         curl http://hosturl/about
     '''
     app: 'DetectorNode' = request.app
-
-    response = AboutResponse(
-        operation_mode=app.operation_mode.value,
-        state=app.status.state,
-        model_info=app.detector_logic._model_info,  # pylint: disable=protected-access
-        target_model=app.target_model.version if app.target_model is not None else None,
-        version_control=app.version_control.value
-    )
-
-    return response
+    return app.get_about_response()

learning_loop_node/detector/rest/model_version_control.py

@@ -1,14 +1,10 @@
 
-import os
 import sys
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING
 
 from fastapi import APIRouter, HTTPException, Request
 
-from ...data_classes import ModelInformation
-from ...globals import GLOBALS
+from ...data_classes import ModelVersionResponse
 
 if TYPE_CHECKING:
     from ..detector_node import DetectorNode
@@ -17,22 +13,7 @@ KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) e
 router = APIRouter()
 
 
-class VersionMode(str, Enum):
-    FollowLoop = 'follow_loop'  # will follow the loop
-    SpecificVersion = 'specific_version'  # will follow the specific version
-    Pause = 'pause'  # will pause the updates
-
-
-@dataclass(**KWONLY_SLOTS)
-class ModelVersionResponse:
-    current_version: str = field(metadata={"description": "The version of the model currently used by the detector."})
-    target_version: str = field(metadata={"description": "The target model version set in the detector."})
-    loop_version: str = field(metadata={"description": "The target model version specified by the loop."})
-    local_versions: List[str] = field(metadata={"description": "The locally available versions of the model."})
-    version_control: str = field(metadata={"description": "The version control mode."})
-
-
-@router.get("/model_version")
+@router.get("/model_version", name='Get model version information', response_model=ModelVersionResponse)
 async def get_version(request: Request):
     '''
     Get information about the model version control and the current model version.
@@ -41,31 +22,11 @@ async def get_version(request: Request):
         curl http://localhost/model_version
     '''
     # pylint: disable=protected-access
-
     app: 'DetectorNode' = request.app
+    return app.get_model_version_response()
 
-    current_version = app.detector_logic._model_info.version if app.detector_logic._model_info is not None else 'None'
-    target_version = app.target_model.version if app.target_model is not None else 'None'
-    loop_version = app.loop_deployment_target.version if app.loop_deployment_target is not None else 'None'
-
-    local_versions: list[str] = []
-    models_path = os.path.join(GLOBALS.data_folder, 'models')
-    local_models = os.listdir(models_path) if os.path.exists(models_path) else []
-    for model in local_models:
-        if model.replace('.', '').isdigit():
-            local_versions.append(model)
-
-    response = ModelVersionResponse(
-        current_version=current_version,
-        target_version=target_version,
-        loop_version=loop_version,
-        local_versions=local_versions,
-        version_control=app.version_control.value,
-    )
-    return response
 
-
-@router.put("/model_version")
+@router.put("/model_version", name='Set model version control mode')
 async def put_version(request: Request):
     '''
     Set the model version control mode.
@@ -77,42 +38,9 @@ async def put_version(request: Request):
     '''
     app: 'DetectorNode' = request.app
     content = str(await request.body(), 'utf-8')
-
-    if content == 'follow_loop':
-        app.version_control = VersionMode.FollowLoop
-    elif content == 'pause':
-        app.version_control = VersionMode.Pause
-    else:
-        app.version_control = VersionMode.SpecificVersion
-        if not content or not content.replace('.', '').isdigit():
-            raise HTTPException(400, 'Invalid version number')
-        target_version = content
-
-        if app.target_model is not None and app.target_model.version == target_version:
-            return "OK"
-
-        # Fetch the model uuid by version from the loop
-        uri = f'/{app.organization}/projects/{app.project}/models'
-        response = await app.loop_communicator.get(uri)
-        if response.status_code != 200:
-            app.version_control = VersionMode.Pause
-            raise HTTPException(500, 'Failed to load models from learning loop')
-
-        models = response.json()['models']
-        models_with_target_version = [m for m in models if m['version'] == target_version]
-        if len(models_with_target_version) == 0:
-            app.version_control = VersionMode.Pause
-            raise HTTPException(400, f'No Model with version {target_version}')
-        if len(models_with_target_version) > 1:
-            app.version_control = VersionMode.Pause
-            raise HTTPException(500, f'Multiple models with version {target_version}')
-
-        model_id = models_with_target_version[0]['id']
-        model_host = models_with_target_version[0].get('host', 'unknown')
-
-        app.target_model = ModelInformation(organization=app.organization, project=app.project,
-                                            host=model_host, categories=[],
-                                            id=model_id,
-                                            version=target_version)
+    try:
+        await app.set_model_version_mode(content)
+    except Exception as exc:
+        raise HTTPException(400, str(exc)) from exc
 
     return "OK"

learning_loop_node/detector/rest/operation_mode.py

@@ -1,24 +1,17 @@
 import logging
-from enum import Enum
 from typing import TYPE_CHECKING
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import PlainTextResponse
 
+from ...enums import OperationMode
+
 if TYPE_CHECKING:
     from learning_loop_node.detector.detector_node import DetectorNode
 
 router = APIRouter()
 
 
-class OperationMode(str, Enum):
-    Startup = 'startup'  # used until model is loaded
-    Idle = 'idle'  # will check and perform updates
-    Detecting = 'detecting'  # Blocks updates
-
-# NOTE: This is only ment to be used by a detector node
-
-
 @router.put("/operation_mode")
 async def put_operation_mode(request: Request):
     '''

learning_loop_node/enums/__init__.py

@@ -0,0 +1,6 @@
+from .annotator import AnnotationEventType
+from .detector import OperationMode, OutboxMode, VersionMode
+from .general import CategoryType
+from .trainer import TrainerState
+
+__all__ = ['VersionMode', 'OperationMode', 'OutboxMode', 'AnnotationEventType', 'CategoryType', 'TrainerState']

learning_loop_node/enums/annotator.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class AnnotationEventType(str, Enum):
+    LeftMouseDown = 'left_mouse_down'
+    RightMouseDown = 'right_mouse_down'
+    MouseMove = 'mouse_move'
+    LeftMouseUp = 'left_mouse_up'
+    RightMouseUp = 'right_mouse_up'
+    KeyUp = 'key_up'
+    KeyDown = 'key_down'

learning_loop_node/enums/detector.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class VersionMode(str, Enum):
+    FollowLoop = 'follow_loop'  # will follow the loop
+    SpecificVersion = 'specific_version'  # will follow the specific version
+    Pause = 'pause'  # will pause the updates
+
+
+class OperationMode(str, Enum):
+    Startup = 'startup'  # used until model is loaded
+    Idle = 'idle'  # will check and perform updates
+    Detecting = 'detecting'  # Blocks updates
+
+
+class OutboxMode(Enum):
+    CONTINUOUS_UPLOAD = 'continuous_upload'
+    STOPPED = 'stopped'

learning_loop_node/enums/general.py

@@ -0,0 +1,9 @@
+
+from enum import Enum
+
+
+class CategoryType(str, Enum):
+    Box = 'box'
+    Point = 'point'
+    Segmentation = 'segmentation'
+    Classification = 'classification'

learning_loop_node/enums/trainer.py

@@ -0,0 +1,22 @@
+
+from enum import Enum
+
+
+class TrainerState(str, Enum):
+    Idle = 'idle'
+    Initialized = 'initialized'
+    Preparing = 'preparing'
+    DataDownloading = 'data_downloading'
+    DataDownloaded = 'data_downloaded'
+    TrainModelDownloading = 'train_model_downloading'
+    TrainModelDownloaded = 'train_model_downloaded'
+    TrainingRunning = 'running'
+    TrainingFinished = 'training_finished'
+    ConfusionMatrixSyncing = 'confusion_matrix_syncing'
+    ConfusionMatrixSynced = 'confusion_matrix_synced'
+    TrainModelUploading = 'train_model_uploading'
+    TrainModelUploaded = 'train_model_uploaded'
+    Detecting = 'detecting'
+    Detected = 'detected'
+    DetectionUploading = 'detection_uploading'
+    ReadyForCleanup = 'ready_for_cleanup'

learning_loop_node/node.py

@@ -73,6 +73,15 @@ class Node(FastAPI):
 
         self.repeat_loop_lock = asyncio.Lock()
 
+        self.previous_state: Optional[str] = None
+
+    def log_status_on_change(self, current_state_str: str, full_status: Any):
+        if self.previous_state != current_state_str:
+            self.previous_state = current_state_str
+            self.log.info('Status changed to %s', full_status)
+        else:
+            self.log.debug('sending status %s', full_status)
+
     def init_loop_communicator(self):
         self.loop_communicator = LoopCommunicator()
         self.websocket_url = self.loop_communicator.websocket_url()

learning_loop_node/tests/annotator/test_annotator_node.py

@@ -7,8 +7,8 @@ from fastapi.encoders import jsonable_encoder
 
 from ...annotation.annotator_logic import AnnotatorLogic
 from ...annotation.annotator_node import AnnotatorNode
-from ...data_classes import (AnnotationData, AnnotationEventType, Category, CategoryType, Context, Point, ToolOutput,
-                             UserInput)
+from ...data_classes import AnnotationData, Category, Context, Point, ToolOutput, UserInput
+from ...enums import AnnotationEventType, CategoryType
 
 
 class MockedAnnotatatorLogic(AnnotatorLogic):

learning_loop_node/tests/general/test_data_classes.py

@@ -3,7 +3,8 @@ from dataclasses import asdict
 from dacite import from_dict
 from fastapi.encoders import jsonable_encoder
 
-from ...data_classes import AnnotationData, AnnotationEventType, Category, Context, Point
+from ...data_classes import AnnotationData, Category, Context, Point
+from ...enums import AnnotationEventType
 
 # Used by all Nodes
 

learning_loop_node/tests/trainer/states/test_state_detecting.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from ....data_classes import TrainerState
+from ....enums import TrainerState
 from ....trainer.trainer_logic import TrainerLogic
 from ...test_helper import get_dummy_detections
 from ..state_helper import assert_training_state, create_active_training_file

learning_loop_node/tests/trainer/states/test_state_download_train_model.py

@@ -2,7 +2,7 @@
 import asyncio
 import os
 
-from ....data_classes import TrainerState
+from ....enums import TrainerState
 from ... import test_helper
 from ..state_helper import assert_training_state, create_active_training_file
 from ..testing_trainer_logic import TestingTrainerLogic

learning_loop_node/tests/trainer/states/test_state_prepare.py

@@ -1,6 +1,7 @@
 import asyncio
 
-from ....data_classes import Context, TrainerState
+from ....data_classes import Context
+from ....enums import TrainerState
 from ....trainer.trainer_logic import TrainerLogic
 from ..state_helper import assert_training_state, create_active_training_file
 from ..testing_trainer_logic import TestingTrainerLogic

learning_loop_node/tests/trainer/states/test_state_sync_confusion_matrix.py

@@ -3,7 +3,7 @@ import asyncio
 
 from pytest_mock import MockerFixture  # pip install pytest-mock
 
-from ....data_classes import TrainerState
+from ....enums import TrainerState
 from ....trainer.trainer_logic import TrainerLogic
 from ....trainer.trainer_node import TrainerNode
 from ..state_helper import assert_training_state, create_active_training_file

learning_loop_node/tests/trainer/states/test_state_train.py

@@ -1,4 +1,4 @@
-from ....data_classes import TrainerState
+from ....enums import TrainerState
 from ...test_helper import condition
 from ..state_helper import assert_training_state, create_active_training_file
 from ..testing_trainer_logic import TestingTrainerLogic

learning_loop_node/tests/trainer/states/test_state_upload_detections.py

@@ -3,7 +3,8 @@ import asyncio
 import pytest
 from dacite import from_dict
 
-from ....data_classes import BoxDetection, Context, Detections, TrainerState
+from ....data_classes import BoxDetection, Context, Detections
+from ....enums import TrainerState
 from ....loop_communication import LoopCommunicator
 from ....trainer.trainer_logic import TrainerLogic
 from ...test_helper import get_dummy_detections

learning_loop_node/tests/trainer/states/test_state_upload_model.py

@@ -2,7 +2,8 @@ import asyncio
 
 from pytest_mock import MockerFixture
 
-from ....data_classes import Context, TrainerState
+from ....data_classes import Context
+from ....enums import TrainerState
 from ....trainer.trainer_logic import TrainerLogic
 from ..state_helper import assert_training_state, create_active_training_file
 from ..testing_trainer_logic import TestingTrainerLogic

learning_loop_node/tests/trainer/test_errors.py

@@ -3,7 +3,7 @@ import re
 
 import pytest
 
-from ...data_classes import TrainerState
+from ...enums import TrainerState
 from .state_helper import assert_training_state, create_active_training_file
 from .testing_trainer_logic import TestingTrainerLogic
 

learning_loop_node/tests/trainer/test_trainer_states.py

@@ -1,7 +1,8 @@
 
 from uuid import uuid4
 
-from ...data_classes import Context, TrainerState, Training
+from ...data_classes import Context, Training
+from ...enums import TrainerState
 from ...trainer.io_helpers import LastTrainingIO
 from ...trainer.trainer_node import TrainerNode
 from .testing_trainer_logic import TestingTrainerLogic

learning_loop_node/trainer/trainer_logic.py

@@ -9,7 +9,8 @@ from typing import Coroutine, List, Optional
 
 from dacite import from_dict
 
-from ..data_classes import Detections, ModelInformation, TrainerState, TrainingError
+from ..data_classes import Detections, ModelInformation, TrainingError
+from ..enums import TrainerState
 from ..helpers.misc import create_image_folder, create_project_folder, images_for_ids, is_valid_uuid4
 from .executor import Executor
 from .trainer_logic_generic import TrainerLogicGeneric

learning_loop_node/trainer/trainer_logic_generic.py

@@ -10,8 +10,8 @@ from typing import TYPE_CHECKING, Callable, Coroutine, Dict, List, Optional
 
 from fastapi.encoders import jsonable_encoder
 
-from ..data_classes import (Context, Errors, PretrainedModel, TrainerState, Training, TrainingOut, TrainingStateData,
-                            TrainingStatus)
+from ..data_classes import Context, Errors, PretrainedModel, Training, TrainingOut, TrainingStateData, TrainingStatus
+from ..enums import TrainerState
 from ..helpers.misc import create_project_folder, delete_all_training_folders, is_valid_uuid4
 from .downloader import TrainingsDownloader
 from .exceptions import CriticalError, NodeNeedsRestartError
@@ -348,6 +348,7 @@ class TrainerLogicGeneric(ABC):
 
         logger.info('loading model from Learning Loop')
         logger.info('downloading model %s as %s', base_model_uuid, self.model_format)
+        assert base_model_uuid is not None
         await self.node.data_exchanger.download_model(self.training.training_folder, self.training.context, base_model_uuid, self.model_format)
         shutil.move(f'{self.training.training_folder}/model.json',
                     f'{self.training.training_folder}/base_model.json')

learning_loop_node/trainer/trainer_node.py

@@ -81,7 +81,8 @@ class TrainerNode(Node):
             return
 
         status = self.trainer_logic.generate_status_for_loop(self.uuid, self.name)
-        self.log.debug('sending status: %s', status.short_str())
+        self.log_status_on_change(status.state or 'None', status.short_str())
+
         result = await self.sio_client.call('update_trainer', jsonable_encoder(asdict(status)), timeout=30)
         if isinstance(result, Dict) and not result['success']:
             self.socket_connection_broken = True

{learning_loop_node-0.12.1.dist-info → learning_loop_node-0.13.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learning-loop-node
-Version: 0.12.1
+Version: 0.13.1
 Summary: Python Library for Nodes which connect to the Zauberzeug Learning Loop
 Home-page: https://github.com/zauberzeug/learning_loop_node
 License: MIT
@@ -106,11 +106,11 @@ The detector also has a sio **upload endpoint** that can be used to upload image
 
 The endpoint returns None if the upload was successful and an error message otherwise.
 
-### Changing the model version
+### Changing the model versioning mode
 
 The detector can be configured to one of the following behaviors:
 
-- download use a specific model version
+- use a specific model version
 - automatically update the model version according to the learning loop deployment target
 - pause the model updates and use the version that was last loaded
 
@@ -124,6 +124,15 @@ The model versioning configuration can be accessed/changed via a REST endpoint.
 Note that the configuration is not persistent, however, the default behavior on startup can be configured via the environment variable `VERSION_CONTROL_DEFAULT`.
 If the environment variable is set to `VERSION_CONTROL_DEFAULT=PAUSE`, the detector will pause the model updates on startup. Otherwise, the detector will automatically follow the loop deployment target.
 
+The model versioning configuration can also be changed via a socketio event:
+
+- Configure the detector to use a specific model version: `sio.emit('set_model_version_mode', '1.0')`
+- Configure the detector to automatically update the model version: `sio.emit('set_model_version_mode', 'follow_loop')`
+- Pause the model updates: `sio.emit('set_model_version_mode', 'pause')`
+
+There is also a GET endpoint to fetch the current model versioning configuration:
+`sio.emit('get_model_version')` or `curl http://localhost/model_version`
+
 ### Changing the outbox mode
 
 If the autoupload is set to `all` or `filtered` (selected) images and the corresponding detections are saved on HDD (the outbox). A background thread will upload the images and detections to the Learning Loop. The outbox is located in the `outbox` folder in the root directory of the node. The outbox can be cleared by deleting the files in the folder.
@@ -138,6 +147,16 @@ Example Usage:
 The current state can be queried via a GET request:
 `curl http://localhost/outbox_mode`
 
+Alternatively, the outbox mode can be changed via a socketio event:
+
+- Enable upload: `sio.emit('set_outbox_mode', 'continuous_upload')`
+- Disable upload: `sio.emit('set_outbox_mode', 'stopped')`
+
+The outbox mode can also be queried via:
+
+- HTTP: `curl http://localhost/outbox_mode`
+- SocketIO: `sio.emit('get_outbox_mode')`
+
 ### Explicit upload
 
 The detector has a REST endpoint to upload images (and detections) to the Learning Loop. The endpoint takes a POST request with the image and optionally the detections. The image is expected to be in jpg format. The detections are expected to be a json dictionary. Example:

{learning_loop_node-0.12.1.dist-info → learning_loop_node-0.13.1.dist-info}/RECORD

@@ -1,30 +1,35 @@
 learning_loop_node/__init__.py,sha256=onN5s8-x_xBsCM6NLmJO0Ym1sJHeCFaGw8qb0oQZmz8,364
 learning_loop_node/annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/annotation/annotator_logic.py,sha256=BTaopkJZkIf1CI5lfsVKsxbxoUIbDJrevavuQUT5e_c,1000
-learning_loop_node/annotation/annotator_node.py,sha256=UrJ8MpZ44UhsjmVuSHr2BhHyLC-kIMDi3IuBBMKzN1g,4117
-learning_loop_node/data_classes/__init__.py,sha256=OZMvTALB_vRz1wnmIPy2mRXteZmot2HZJmhAKBWKrWg,1284
-learning_loop_node/data_classes/annotations.py,sha256=iInU0Nuy_oYT_sj4k_n-W0UShCBI2cHQYrt8imymbtM,1211
+learning_loop_node/annotation/annotator_node.py,sha256=Ac6tuiO-Ne8m8XLDBK_ucRhofiudRUIjL1nM-rkUkGE,4156
+learning_loop_node/data_classes/__init__.py,sha256=GUFbVDT8ywGUpEMhV4WZHwvD2yM9A0eAvPydHeq6gyA,1233
+learning_loop_node/data_classes/annotations.py,sha256=NfMlTv2_5AfVY_JDM4tbjETFjSN2S2I2LJJPMMcDT50,966
 learning_loop_node/data_classes/detections.py,sha256=7vqcS0EK8cmDjRDckHlpSZDZ9YO6qajRmYvx-oxatFc,5425
-learning_loop_node/data_classes/general.py,sha256=DIJnmLmbnVgg8Xzg6CKIeQpM7EQhiGcOjeqzNn2NRIA,6194
+learning_loop_node/data_classes/general.py,sha256=r7fVfuQvbo8qOTT7zylgfM45TbIvYu8bkDIAZ3wszqA,7397
 learning_loop_node/data_classes/image_metadata.py,sha256=56nNSf_7aMlvKsJOG8vKCzJHcqKGHVRoULp85pJ2imA,1598
 learning_loop_node/data_classes/socket_response.py,sha256=tIdt-oYf6ULoJIDYQCecNM9OtWR6_wJ9tL0Ksu83Vko,655
-learning_loop_node/data_classes/training.py,sha256=Lr1dhRyYpv3ctD7ifFMwhqbS3Mx9yi0zVOxEi-V7uC8,6438
+learning_loop_node/data_classes/training.py,sha256=FFPsr2AA7ynYz39MLZaFJ0sF_9Axll5HHbAA8nnirp0,5726
 learning_loop_node/data_exchanger.py,sha256=IG5ki3f3IsVuXbyw6q_gUIakgv-GMT6e9nhOhzjKgW4,9055
 learning_loop_node/detector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_loop_node/detector/detector_logic.py,sha256=fAaeLykvkuOeaQx-scuN1pkydK8cPdmNT75P8xqImY0,2130
-learning_loop_node/detector/detector_node.py,sha256=ryzPcv5wfNjA_Sk5YDcUkZoKEUGPT1s29rvFLGGPIZ8,19929
+learning_loop_node/detector/detector_logic.py,sha256=FhGbu0mdF0tW0Gg8cr8xM6ZmZzEigGf0IcAWBjoxFrs,2191
+learning_loop_node/detector/detector_node.py,sha256=ud5jFhazk_8wKzrwtpWRwVsLQkWzskzCnymAKbJW7H0,24921
 learning_loop_node/detector/inbox_filter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/detector/inbox_filter/cam_observation_history.py,sha256=8gzxYPD3t1OS9wBHXfIvNV2xTTMo0B70O1b50iaH2D8,3344
 learning_loop_node/detector/inbox_filter/relevance_filter.py,sha256=NPEmrAtuGjIWCtHS0B3zDmnYWkhVFCLbd_7RUp08_AM,1372
-learning_loop_node/detector/outbox.py,sha256=AIoQFCX3CA4jcQWKcmCkL9su1SWMDci7p-Xip0kNbTE,8643
+learning_loop_node/detector/outbox.py,sha256=CYuXI6uXQ_mrVPZ0qvNgdSZH1nLarcs7Fj_7Mb3k7MA,8558
 learning_loop_node/detector/rest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-learning_loop_node/detector/rest/about.py,sha256=COYgmYO1tXGSIwjF__P79mVZUfSDZoHsW0GUarQ2rv0,1686
+learning_loop_node/detector/rest/about.py,sha256=evHJ2svUZY_DFz0FSef5u9c5KW4Uc3GL7EbPinG9-dg,583
 learning_loop_node/detector/rest/backdoor_controls.py,sha256=ZNaFOvC0OLWNtcLiG-NIqS_y1kkLP4csgk3CHhp8Gis,885
 learning_loop_node/detector/rest/detect.py,sha256=ofJ3ysTarbCpiH1YAD6gSJbrDOzAcsLRuGxhr57dtk0,2503
-learning_loop_node/detector/rest/model_version_control.py,sha256=jLp3rvCYq8T_QC3KK7uLDYpbDjydwazWkQCUXvkxl-c,4654
-learning_loop_node/detector/rest/operation_mode.py,sha256=RAzVLtGzy4n9-LSIq_XSwMfXDehU4XmorgWAWbQ6BW8,1804
+learning_loop_node/detector/rest/model_version_control.py,sha256=P4FOG0U9HT6QtCoNt-1s1pT6drtgdVjGZWEuCAyuNmA,1370
+learning_loop_node/detector/rest/operation_mode.py,sha256=1_xfutA_6nzdb4Q_jZiHQ5m_wA83bcG5jSIy-sfNIvk,1575
 learning_loop_node/detector/rest/outbox_mode.py,sha256=H8coDNbgLGEfXmKQrhtXWeUHBAHpnrdZktuHXQz0xis,1148
 learning_loop_node/detector/rest/upload.py,sha256=5YWY0Ku4duZqKd6tjyJzq-Ga83o2UYb1VmzuxBIgo0w,1061
+learning_loop_node/enums/__init__.py,sha256=tjSrhztIQ8W656_QuXfTbbVNtH_wDXP5hpYZgzfgRhc,285
+learning_loop_node/enums/annotator.py,sha256=mtTAw-8LJIrHcYkBjYHCZuhYEEHS6QzSK8k6BhLusvQ,285
+learning_loop_node/enums/detector.py,sha256=Qvm5LWWR9BfsDxHEQ8YzaPaUuSmp4BescYuV4X4ikwE,512
+learning_loop_node/enums/general.py,sha256=OSpcIpdFjuRByON2xBoiIXl1SgDREIqkwnaxkTFjnHU,164
+learning_loop_node/enums/trainer.py,sha256=VaD63guLO4aKgVfXT0EryPlXKQGegSET3Cp4R0uC_Ew,746
 learning_loop_node/examples/novelty_score_updater.py,sha256=1DRgM9lxjFV-q2JvGDDsNLz_ic_rhEZ9wc6ZdjcxwPE,2038
 learning_loop_node/globals.py,sha256=tgw_8RYOipPV9aYlyUhYtXfUxvJKRvfUk6u-qVAtZmY,174
 learning_loop_node/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -33,14 +38,14 @@ learning_loop_node/helpers/gdrive_downloader.py,sha256=zeYJciTAJVRpu_eFjwgYLCpIa
 learning_loop_node/helpers/log_conf.py,sha256=hqVAa_9NnYEU6N0dcOKmph82p7MpgKqeF_eomTLYzWY,961
 learning_loop_node/helpers/misc.py,sha256=J29iBmsEUAraKKDN1m1NKiHQ3QrP5ub5HBU6cllSP2g,7384
 learning_loop_node/loop_communication.py,sha256=kc7GrkUS14Ka5OICaaOd_LZ61D-6O19GcyDEwckTxvM,7286
-learning_loop_node/node.py,sha256=z2CG4s_uvboY7pBQ8JlJr5s67Hf31ckfGjaRulsrqy0,10593
+learning_loop_node/node.py,sha256=rBdZiBzp7VqQkIt9GJ8b4nK2Y54lUJFzK-gc7rb14cA,10966
 learning_loop_node/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/rest.py,sha256=omwlRHLnyG-kgCBVnZDk5_SAPobL9g7slWeX21wsPGw,1551
 learning_loop_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/annotator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/annotator/conftest.py,sha256=G4ZvdZUdvPp9bYCzg3eEVkGCeXn9INZ3AcN7d5CyLkU,1931
 learning_loop_node/tests/annotator/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0W5UOnDfGGs_igU,262
-learning_loop_node/tests/annotator/test_annotator_node.py,sha256=TPNPPrQAxQ_zEecQcH7hlczgD3ABtTCNtUvWD1_oApk,1985
+learning_loop_node/tests/annotator/test_annotator_node.py,sha256=UWRXRSBc1e795ftkp7xrEXbyR4LYvFDDHRpZGqC3vr8,1974
 learning_loop_node/tests/detector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/detector/conftest.py,sha256=4zNW8dnwj3CDKCkFNVCPbHgFTYtDvdaqnUM4s_I-cq4,5328
 learning_loop_node/tests/detector/inbox_filter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -60,7 +65,7 @@ learning_loop_node/tests/general/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0
 learning_loop_node/tests/general/test_data/file_1.txt,sha256=Lis06nfvbFPVCBZyEgQlfI_Nle2YDq1GQBlYvEfFtxw,19
 learning_loop_node/tests/general/test_data/file_2.txt,sha256=Xp8EETGhZBdVAgb4URowSSpOytwwwJdV0Renkdur7R8,19
 learning_loop_node/tests/general/test_data/model.json,sha256=_xNDucGOWila8gWnu8yFfrqmQ45Xq-_39eLKzjRtvpE,516
-learning_loop_node/tests/general/test_data_classes.py,sha256=u5GoXNk2yqCp1EVm9YoBnYreL2SCjgJ0a3x01JQDOuM,701
+learning_loop_node/tests/general/test_data_classes.py,sha256=RnDzRtB-eRfWnaaA6qAzC1W8wurFzJ4xt1Q5pd7ZCS0,721
 learning_loop_node/tests/general/test_downloader.py,sha256=y4GcUyR0OAfrwltd6eyQgopwTt3DwjzX0Sr8yrooLec,3347
 learning_loop_node/tests/general/test_learning_loop_node.py,sha256=SZd-VChpWnnsPN46pr4E_LL3ZevYx6psU-AWdVeOFpQ,770
 learning_loop_node/tests/test_helper.py,sha256=Xajn6BWJqeD36YAETwdcJd6awY2NPmaOis3gWgFc97k,2909
@@ -70,15 +75,15 @@ learning_loop_node/tests/trainer/pytest.ini,sha256=8QdjmawLy1zAzXrJ88or1kpFDhJw0
 learning_loop_node/tests/trainer/state_helper.py,sha256=MDe9opeKruip74FoRFff8MSWGiQNFqDpPtIEIbgPnFc,919
 learning_loop_node/tests/trainer/states/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/tests/trainer/states/test_state_cleanup.py,sha256=gZNxSSwnj9f0esExNnQzqadM6-sE3IsF5sNbD0bZNu8,1250
-learning_loop_node/tests/trainer/states/test_state_detecting.py,sha256=KGXTR69J_1pJoT8S0ceC3vSyHLw52mIpjbawH4c-8JA,3696
-learning_loop_node/tests/trainer/states/test_state_download_train_model.py,sha256=rgMcPtG2mu8ojT6ftcIzA1oWOLo0cubuaEofKXgoUYo,2999
-learning_loop_node/tests/trainer/states/test_state_prepare.py,sha256=N9A8UDVoiXvMd1htqigYfuRAqpq2VjnfKlP4EROJnX8,2270
-learning_loop_node/tests/trainer/states/test_state_sync_confusion_matrix.py,sha256=wMUhw6t2Hv7dx1_wh8W748oRhMvy_O3TB3lBzEWmPiE,5111
-learning_loop_node/tests/trainer/states/test_state_train.py,sha256=IBOtnkDApwfaoEavFWgydxXwRXOPfj8-U78r1tdJH_k,2900
-learning_loop_node/tests/trainer/states/test_state_upload_detections.py,sha256=0Qkavl4i2tZmCOxKkNsQUqa1JWhAgcOsbrW3_eYHfxo,7417
-learning_loop_node/tests/trainer/states/test_state_upload_model.py,sha256=y2o4WBo7kBG_JWSWmt4icjrwya5hQ30zCWC-YMVEwEk,3621
-learning_loop_node/tests/trainer/test_errors.py,sha256=khWCTzi-JW4nSz9QnsRh9wDPmiuE_zdxXukh59qixuY,2109
-learning_loop_node/tests/trainer/test_trainer_states.py,sha256=SJqbh6DiLn7_D62DTIxDcBnPV4iPOdJms_aTytw3INc,1218
+learning_loop_node/tests/trainer/states/test_state_detecting.py,sha256=-NLR5se7_OY_X8_Gf-BWw7X6dS_Pzsnkz84J5aTbqFU,3689
+learning_loop_node/tests/trainer/states/test_state_download_train_model.py,sha256=-T8iAutBliv0MV5bV5lPvn2aNjF3vMBCj8iAZTC-Q7g,2992
+learning_loop_node/tests/trainer/states/test_state_prepare.py,sha256=boCU93Bv2VWbW73MC_suTbwCcuR7RWn-6dgVvdiJ9tA,2291
+learning_loop_node/tests/trainer/states/test_state_sync_confusion_matrix.py,sha256=qygblvDhsC7gcteo2puaR16Mqr4d8W2QgfGr6gUPI7s,5104
+learning_loop_node/tests/trainer/states/test_state_train.py,sha256=ovRs8EepQjy0yQJssK0TdcZcraBhmUkbMWeNKdHS114,2893
+learning_loop_node/tests/trainer/states/test_state_upload_detections.py,sha256=oFQGTeRZhW7MBISAfpe65KphZNxFUsZu3-5hD9_LS6k,7438
+learning_loop_node/tests/trainer/states/test_state_upload_model.py,sha256=jHWLa48tNljZwIiqI-1z71ENRGnn7Z0BsVcDBVWVBj4,3642
+learning_loop_node/tests/trainer/test_errors.py,sha256=LdIky-SuR4Owml8FlByD0GXdv3vGh6JuqDQgJfFdgkw,2102
+learning_loop_node/tests/trainer/test_trainer_states.py,sha256=OFrHSjpTIcwDp-QRe8sdseTZr0Z5dVeCt_ani9pfCqI,1238
 learning_loop_node/tests/trainer/testing_trainer_logic.py,sha256=vaz7EbsVRcSMyAfEGpXgNFj1yQc9dYLCYDrjjmYTZ1o,3765
 learning_loop_node/trainer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/trainer/downloader.py,sha256=AIyEKM4XYtd6VgmXrP3VayV9DpJzdURK1Brx81ePNSM,1470
@@ -88,9 +93,9 @@ learning_loop_node/trainer/io_helpers.py,sha256=ZnAPVqhq8XCHe1NoiOQJ_w0B-estcc8C
 learning_loop_node/trainer/rest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_loop_node/trainer/rest/backdoor_controls.py,sha256=ZnK8ypY5r_q0-YZbtaOxhQThzuZvMsQHM5gJGESd_dE,5131
 learning_loop_node/trainer/test_executor.py,sha256=6BVGDN_6f5GEMMEvDLSG1yzMybSvgXaP5uYpSfsVPP0,2224
-learning_loop_node/trainer/trainer_logic.py,sha256=SHzoCb_hwI3zC6VCW_7jWi45Ng3etEo6WepFntS3pnA,8773
-learning_loop_node/trainer/trainer_logic_generic.py,sha256=WM0gaTln0wjNKemNpxhCHRQCTEj_TVPgN1oMNXkacSU,26795
-learning_loop_node/trainer/trainer_node.py,sha256=9nk_LH4jmuUzZ5ApOGvut1RAcyULU7DtiIgtjKzIrpU,4494
-learning_loop_node-0.12.1.dist-info/METADATA,sha256=jyoFDT7gR4Fao2T3wlvr5X9UYeeiD1Som8s4Qi73Q-k,11906
-learning_loop_node-0.12.1.dist-info/WHEEL,sha256=WGfLGfLX43Ei_YORXSnT54hxFygu34kMpcQdmgmEwCQ,88
-learning_loop_node-0.12.1.dist-info/RECORD,,
+learning_loop_node/trainer/trainer_logic.py,sha256=eK-01qZzi10UjLMCQX8vy5eW2FoghPj3rzzDC-s3Si4,8792
+learning_loop_node/trainer/trainer_logic_generic.py,sha256=JGH2IClpte8WqO_Pmh7Epa-328Pyl5RYYZlWgOdygvs,26827
+learning_loop_node/trainer/trainer_node.py,sha256=Dl4ZQAjjXQggibeBjvhXAoFClw1ZX2Kkt3v_fjrJnCI,4508
+learning_loop_node-0.13.1.dist-info/METADATA,sha256=uR7jIEJgo8EPnOimjLXTu2IM58cgLiHUVfPTD78xc9o,12761
+learning_loop_node-0.13.1.dist-info/WHEEL,sha256=WGfLGfLX43Ei_YORXSnT54hxFygu34kMpcQdmgmEwCQ,88
+learning_loop_node-0.13.1.dist-info/RECORD,,