learning-loop-node 0.12.1__tar.gz → 0.13.1__tar.gz

{learning_loop_node-0.12.1 → learning_loop_node-0.13.1}/PKG-INFO

@@ -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 → learning_loop_node-0.13.1}/README.md

@@ -66,11 +66,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
 
@@ -84,6 +84,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.
@@ -98,6 +107,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 → learning_loop_node-0.13.1}/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-0.13.1/learning_loop_node/data_classes/__init__.py

@@ -0,0 +1,19 @@
+from .annotations import AnnotationData, SegmentationAnnotation, ToolOutput, UserInput
+from .detections import (BoxDetection, ClassificationDetection, Detections, Observation, Point, PointDetection,
+                         SegmentationDetection, Shape)
+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, Training, TrainingError, TrainingOut, TrainingStateData, TrainingStatus
+
+__all__ = [
+    'AboutResponse', 'AnnotationData', 'SegmentationAnnotation', 'ToolOutput', 'UserInput',
+    'BoxDetection', 'ClassificationDetection', 'ImageMetadata', 'Observation', 'Point', 'PointDetection',
+    'SegmentationDetection', 'Shape', 'Detections',
+    'AnnotationNodeStatus', 'Category', 'Context', 'DetectionStatus', 'ErrorConfiguration',
+    'ModelInformation', 'NodeState', 'NodeStatus', 'ModelVersionResponse',
+    'SocketResponse',
+    'Errors', 'PretrainedModel', 'Training',
+    'TrainingError', 'TrainingOut', 'TrainingStateData', 'TrainingStatus',
+]

{learning_loop_node-0.12.1 → learning_loop_node-0.13.1}/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-0.12.1 → learning_loop_node-0.13.1}/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-0.12.1 → learning_loop_node-0.13.1}/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-0.12.1 → learning_loop_node-0.13.1}/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-0.12.1 → learning_loop_node-0.13.1}/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-0.12.1 → learning_loop_node-0.13.1}/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-0.13.1/learning_loop_node/detector/rest/about.py

@@ -0,0 +1,26 @@
+
+import sys
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter, Request
+
+from ...data_classes import AboutResponse
+
+if TYPE_CHECKING:
+    from ..detector_node import DetectorNode
+KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
+
+router = APIRouter()
+
+
+@router.get("/about", response_model=AboutResponse)
+async def get_about(request: Request):
+    '''
+    Get information about the detector node.
+
+    Example Usage
+
+        curl http://hosturl/about
+    '''
+    app: 'DetectorNode' = request.app
+    return app.get_about_response()

learning_loop_node-0.13.1/learning_loop_node/detector/rest/model_version_control.py

@@ -0,0 +1,46 @@
+
+import sys
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter, HTTPException, Request
+
+from ...data_classes import ModelVersionResponse
+
+if TYPE_CHECKING:
+    from ..detector_node import DetectorNode
+KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
+
+router = APIRouter()
+
+
+@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.
+
+    Example Usage
+        curl http://localhost/model_version
+    '''
+    # pylint: disable=protected-access
+    app: 'DetectorNode' = request.app
+    return app.get_model_version_response()
+
+
+@router.put("/model_version", name='Set model version control mode')
+async def put_version(request: Request):
+    '''
+    Set the model version control mode.
+
+    Example Usage
+        curl -X PUT -d "follow_loop" http://hosturl/model_version
+        curl -X PUT -d "pause" http://hosturl/model_version
+        curl -X PUT -d "13.6" http://hosturl/model_version
+    '''
+    app: 'DetectorNode' = request.app
+    content = str(await request.body(), 'utf-8')
+    try:
+        await app.set_model_version_mode(content)
+    except Exception as exc:
+        raise HTTPException(400, str(exc)) from exc
+
+    return "OK"

{learning_loop_node-0.12.1 → learning_loop_node-0.13.1}/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-0.13.1/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-0.13.1/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'