learning-loop-node 0.10.13__py3-none-any.whl → 0.10.14__py3-none-any.whl

learning_loop_node/annotation/annotator_node.py

@@ -22,7 +22,6 @@ class AnnotatorNode(Node):
         self.tool = annotator_logic
         self.histories: Dict = {}
         annotator_logic.init(self)
-        self.status_sent = False
 
     def register_sio_events(self, sio_client: AsyncClient):
 
@@ -66,8 +65,6 @@ class AnnotatorNode(Node):
         return self.histories.setdefault(frontend_id, self.tool.create_empty_history())
 
     async def send_status(self):
-        if self.status_sent:
-            return
 
         status = AnnotationNodeStatus(
             id=self.uuid,
@@ -76,20 +73,24 @@ class AnnotatorNode(Node):
             capabilities=['segmentation']
         )
 
-        self.log.info(f'Sending status {status}')
+        self.log.debug('Sending status %s', status)
         try:
             result = await self.sio_client.call('update_annotation_node', jsonable_encoder(asdict(status)), timeout=10)
-        except Exception as e:
-            self.log.error(f'Error for updating: {str(e)}')
+        except Exception:
+            self.socket_connection_broken = True
+            self.log.exception('Error for updating:')
+            return
+
+        if not isinstance(result, Dict):
+            self.socket_connection_broken = True
+            self.log.error('Expected Dict, got %s', type(result))
             return
 
-        assert isinstance(result, Dict)
         response = from_dict(data_class=SocketResponse, data=result)
 
         if not response.success:
-            self.log.error(f'Error for updating: Response from loop was : {asdict(response)}')
-        else:
-            self.status_sent = True
+            self.socket_connection_broken = True
+            self.log.error('Response from loop was: %s', asdict(response))
 
     async def download_image(self, context: Context, uuid: str):
         project_folder = create_project_folder(context)

learning_loop_node/data_classes/detections.py

@@ -16,14 +16,14 @@ class BoxDetection():
     """Coordinates according to COCO format. x,y is the top left corner of the box.
     x increases to the right, y increases downwards.
     """
-    category_name: str
-    x: int
-    y: int
-    width: int
-    height: int
-    model_name: str
-    confidence: float
-    category_id: Optional[str] = None
+    category_name: str = field(metadata={'description': 'Category name'})
+    x: int = field(metadata={'description': 'X coordinate (left to right)'})
+    y: int = field(metadata={'description': 'Y coordinate (top to bottom)'})
+    width: int = field(metadata={'description': 'Width'})
+    height: int = field(metadata={'description': 'Height'})
+    model_name: str = field(metadata={'description': 'Model name'})
+    confidence: float = field(metadata={'description': 'Confidence'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category ID'})
 
     def intersection_over_union(self, other_detection: 'BoxDetection') -> float:
         # https://www.pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/
@@ -52,12 +52,12 @@ class BoxDetection():
 class PointDetection():
     """Coordinates according to COCO format. x,y is the center of the point.
     x increases to the right, y increases downwards."""
-    category_name: str
-    x: float
-    y: float
-    model_name: str
-    confidence: float
-    category_id: Optional[str] = None
+    category_name: str = field(metadata={'description': 'Category name'})
+    x: float = field(metadata={'description': 'X coordinate (right)'})
+    y: float = field(metadata={'description': 'Y coordinate (down)'})
+    model_name: str = field(metadata={'description': 'Model name'})
+    confidence: float = field(metadata={'description': 'Confidence'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category ID'})
 
     def distance(self, other: 'PointDetection') -> float:
         return np.sqrt((other.x - self.x)**2 + (other.y - self.y)**2)
@@ -68,10 +68,10 @@ class PointDetection():
 
 @dataclass(**KWONLY_SLOTS)
 class ClassificationDetection():
-    category_name: str
-    model_name: str
-    confidence: float
-    category_id: Optional[str] = None
+    category_name: str = field(metadata={'description': 'Category name'})
+    model_name: str = field(metadata={'description': 'Model name'})
+    confidence: float = field(metadata={'description': 'Confidence'})
+    category_id: Optional[str] = field(default=None, metadata={'description': 'Category ID'})
 
     def __str__(self):
         return f'c: {self.confidence:.2f} -> {self.category_name}'
@@ -112,14 +112,22 @@ def current_datetime():
 
 @dataclass(**KWONLY_SLOTS)
 class Detections():
-    box_detections: List[BoxDetection] = field(default_factory=list)
-    point_detections: List[PointDetection] = field(default_factory=list)
-    segmentation_detections: List[SegmentationDetection] = field(default_factory=list)
-    classification_detections: List[ClassificationDetection] = field(default_factory=list)
-    tags: List[str] = field(default_factory=list)
-    date: Optional[str] = field(default_factory=current_datetime)
-    image_id: Optional[str] = None  # (actually UUID) used for detection of trainers
-    source: Optional[str] = None
+    box_detections: List[BoxDetection] = field(default_factory=list, metadata={
+        'description': 'List of box detections'})
+    point_detections: List[PointDetection] = field(default_factory=list, metadata={
+        'description': 'List of point detections'})
+    segmentation_detections: List[SegmentationDetection] = field(default_factory=list, metadata={
+        'description': 'List of segmentation detections'})
+    classification_detections: List[ClassificationDetection] = field(default_factory=list, metadata={
+        'description': 'List of classification detections'})
+    tags: List[str] = field(default_factory=list, metadata={
+        'description': 'List of tags'})
+    date: Optional[str] = field(default_factory=current_datetime, metadata={
+        'description': 'Date of the detections'})
+    image_id: Optional[str] = field(default=None, metadata={
+        'description': 'Image uuid'})
+    source: Optional[str] = field(default=None, metadata={
+        'description': 'Source of the detections'})
 
     def __len__(self):
         return len(self.box_detections) + len(self.point_detections) + len(self.segmentation_detections) + len(self.classification_detections)

learning_loop_node/data_classes/general.py

@@ -20,14 +20,19 @@ class CategoryType(str, Enum):
 
 @dataclass(**KWONLY_SLOTS)
 class Category():
-    id: str  # TODO: rename to identifier or uuid  (cannot be changed because of database / loop communication)
-    name: str
-    description: Optional[str] = None
-    hotkey: Optional[str] = None
-    color: Optional[str] = None
-    point_size: Optional[int] = None
-    # TODO: rename to ctype (cannot be changed because of database / loop communication)
-    type: Optional[Union[CategoryType, str]] = None
+    id: str = field(metadata={"description": "The uuid of the category."})
+    name: str = field(metadata={"description": "The name of the category."})
+    description: Optional[str] = field(default=None, metadata={
+        "description": "An optional description of the category."})
+    hotkey: Optional[str] = field(default=None, metadata={
+        "description": "The key shortcut of the category when annotating in the Learning Loop UI."})
+    color: Optional[str] = field(default=None, metadata={
+        "description": "The color of the category when displayed in the Learning Loop UI."})
+    point_size: Optional[int] = field(default=None, metadata={
+        "description": "The point size of the category in pixels. Represents the uncertainty of the category."})
+    type: Optional[Union[CategoryType, str]] = field(default=None, metadata={
+        "description": "The type of the category",
+        "example": "box, point, segmentation, classification"})
 
     @staticmethod
     def from_list(values: List[dict]) -> List['Category']:
@@ -45,15 +50,20 @@ class Context():
 
 @dataclass(**KWONLY_SLOTS)
 class ModelInformation():
-    id: str
-    host: Optional[str]
-    organization: str
-    project: str
-    version: str
-    categories: List[Category] = field(default_factory=list)
-    resolution: Optional[int] = None
-    model_root_path: Optional[str] = None
-    model_size: Optional[str] = None
+    id: str = field(metadata={"description": "The uuid of the model."})
+    host: Optional[str] = field(metadata={"description": "The hostname that started the training.",
+                                          "example": "learning-loop.ai"})
+    organization: str = field(metadata={"description": "The owner organization of the model."})
+    project: str = field(metadata={"description": "The project of the model."})
+    version: str = field(metadata={"description": "The version of the model."})
+    categories: List[Category] = field(default_factory=list, metadata={
+                                       "description": "The categories used in the model."})
+    resolution: Optional[int] = field(default=None, metadata={
+        "description": "The resolution of the model (width and height of the image after preprocessing in pixels)."})
+    model_root_path: Optional[str] = field(
+        default=None, metadata={"description": "The path of the parent directory of the model in the file system."})
+    model_size: Optional[str] = field(default=None, metadata={
+                                      "description": "The size of the model (i.e. the specification or variant of the model architecture)."})
 
     @property
     def context(self):

learning_loop_node/data_exchanger.py

@@ -140,20 +140,21 @@ class DataExchanger():
         """Downloads a model (and additional meta data like model.json) and returns the paths of the downloaded files.
         Used before training a model (when continuing a finished training) or before detecting images.
         """
-        logging.info(f'Downloading model data for uuid {model_uuid} from the loop to {target_folder}..')
+        logging.info('Downloading model data for uuid %s from the loop to %s..', model_uuid, target_folder)
 
         path = f'/{context.organization}/projects/{context.project}/models/{model_uuid}/{model_format}/file'
         response = await self.loop_communicator.get(path, requires_login=False)
         if response.status_code != 200:
-            content = response.json()
-            logging.error(f'could not download loop/{path}: {response.status_code}, content: {content}')
-            raise DownloadError(content['detail'])
+            decoded_content = response.content.decode('utf-8')
+            logging.error('could not download loop/%s: %s, content: %s', path,
+                          response.status_code, decoded_content)
+            raise DownloadError(decoded_content)
         try:
             provided_filename = response.headers.get(
                 "Content-Disposition").split("filename=")[1].strip('"')
             content = response.content
         except:
-            logging.exception(f'Error during downloading model {path}:')
+            logging.exception('Error while downloading model %s:', path)
             raise
 
         tmp_path = f'/tmp/{os.path.splitext(provided_filename)[0]}'

learning_loop_node/detector/detector_logic.py

@@ -28,7 +28,7 @@ class DetectorLogic():
         return self._model_info is not None
 
     def load_model(self):
-        logging.info(f'Loading model from {GLOBALS.data_folder}/model')
+        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')
@@ -37,9 +37,9 @@ class DetectorLogic():
         try:
             self._model_info = model_info
             self.init()
-            logging.info(f'Successfully loaded model {self._model_info}')
+            logging.info('Successfully loaded model %s', self._model_info)
         except Exception:
-            logging.error(f'Could not init model {model_info}')
+            logging.error('Could not init model %s', model_info)
             raise
 
     @abstractmethod

learning_loop_node/detector/detector_node.py

@@ -93,7 +93,8 @@ class DetectorNode(Node):
         # simulate super().startup
         await self.loop_communicator.backend_ready()
         # await self.loop_communicator.ensure_login()
-        await self.create_sio_client()
+        self.set_skip_repeat_loop(False)
+        self.socket_connection_broken = True
         await self.on_startup()
 
         # simulate startup
@@ -151,8 +152,9 @@ class DetectorNode(Node):
                 )
                 if det is None:
                     return {'error': 'no model loaded'}
+                detection_dict = jsonable_encoder(asdict(det))
                 self.log.debug('detect via socketio finished')
-                return det
+                return detection_dict
             except Exception as e:
                 self.log.exception('could not detect via socketio')
                 with open('/tmp/bad_img_from_socket_io.jpg', 'wb') as f:
@@ -198,23 +200,21 @@ class DetectorNode(Node):
             self.connected_clients.append(sid)
 
     async def _check_for_update(self) -> None:
-        if self.operation_mode == OperationMode.Startup:
-            return
         try:
-            self.log.info('Current operation mode is %s', self.operation_mode)
+            self.log.debug('Current operation mode is %s', self.operation_mode)
             try:
                 await self.sync_status_with_learning_loop()
-            except Exception as e:
-                self.log.error('Could not check for updates: %s', e)
+            except Exception:
+                self.log.exception('Sync with learning loop failed (could not check for updates):')
                 return
 
             if self.operation_mode != OperationMode.Idle:
-                self.log.info('not checking for updates; operation mode is %s', self.operation_mode)
+                self.log.debug('not checking for updates; operation mode is %s', self.operation_mode)
                 return
 
             self.status.reset_error('update_model')
             if self.target_model is None:
-                self.log.info('not checking for updates; no target model selected')
+                self.log.debug('not checking for updates; no target model selected')
                 return
 
             current_version = self.detector_logic._model_info.version if self.detector_logic._model_info is not None else None  # pylint: disable=protected-access
@@ -290,12 +290,15 @@ class DetectorNode(Node):
             model_format=self.detector_logic.model_format,
         )
 
-        self.log.info('sending status %s', status)
+        self.log.debug('sending status %s', 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
+            return
 
-        assert response is not None
         socket_response = from_dict(data_class=SocketResponse, data=response)
         if not socket_response.success:
+            self.socket_connection_broken = True
             self.log.error('Statusupdate failed: %s', response)
             raise Exception(f'Statusupdate failed: {response}')
 
@@ -308,9 +311,12 @@ class DetectorNode(Node):
                                                        id=deployment_target_model_id,
                                                        version=deployment_target_model_version)
 
-        if self.version_control == rest_version_control.VersionMode.FollowLoop:
+        if (self.version_control == rest_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
-            self.log.info('After sending status. Target_model is %s', self.target_model.version)
+            self.log.info('After sending status. Target_model changed from %s to %s',
+                          old_target_model_version, self.target_model.version)
 
     async def set_operation_mode(self, mode: OperationMode):
         self.operation_mode = mode
@@ -337,7 +343,7 @@ class DetectorNode(Node):
                              camera_id: Optional[str],
                              tags: List[str],
                              source: Optional[str] = None,
-                             autoupload: Optional[str] = None) -> Optional[Dict]:
+                             autoupload: Optional[str] = None) -> Detections:
         """ Main processing function for the detector node when an image is received via REST or SocketIO.
         This function infers the detections from the image, cares about uploading to the loop and returns the detections as a dictionary.
         Note: raw_image is a numpy array of type uint8, but not in the correct shape!
@@ -362,7 +368,7 @@ class DetectorNode(Node):
             pass
         else:
             self.log.error('unknown autoupload value %s', autoupload)
-        return jsonable_encoder(asdict(detections))
+        return detections
 
     async def upload_images(self, images: List[bytes]):
         loop = asyncio.get_event_loop()

learning_loop_node/detector/rest/about.py

@@ -1,26 +1,50 @@
 
-from typing import TYPE_CHECKING
+import sys
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Optional
 
 from fastapi import APIRouter, Request
 
+from ...data_classes import ModelInformation
+
 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")
+@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):
     '''
+    Get information about the detector node.
+
     Example Usage
-        curl http://localhost/about
+
+        curl http://hosturl/about
     '''
     app: 'DetectorNode' = request.app
 
-    return {
-        '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,
-    }
+    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

learning_loop_node/detector/rest/backdoor_controls.py

@@ -14,41 +14,24 @@ if TYPE_CHECKING:
 router = APIRouter()
 
 
-@router.put("/socketio")
-async def _socketio(request: Request):
+@router.post("/reset")
+async def _reset(request: Request):
     '''
+    Soft-Reset the detector node.
+
     Example Usage
 
-        curl -X PUT -d "on" http://localhost:8007/socketio
+        curl -X POST http://hosturl/reset
     '''
-    state = str(await request.body(), 'utf-8')
+    logging.info('BC: reset')
     detector_node: 'DetectorNode' = request.app
 
-    if state == 'off':
-        logging.info('BC: turning socketio off')
-        await detector_node.sio_client.disconnect()
-    if state == 'on':
-        logging.info('BC: turning socketio on')
-        await detector_node.connect_sio()
-
-
-@router.post("/reset")
-async def _reset(request: Request):
-    logging.info('BC: reset')
     try:
         shutil.rmtree(GLOBALS.data_folder, ignore_errors=True)
         os.makedirs(GLOBALS.data_folder, exist_ok=True)
 
-        # get file dir
-        # restart_path = Path(os.path.realpath(__file__)) / 'restart' / 'restart.py'
-        # restart_path = Path(os.getcwd()).absolute() / 'app_code' / 'restart' / 'restart.py'
-        # restart_path.touch()
-        # assert isinstance(request.app, 'DetectorNode')
-        await request.app.soft_reload()
-
-        # assert isinstance(request.app, DetectorNode)
-        # request.app.reload(reason='------- reset was called from backdoor controls',)
-    except Exception as e:
-        logging.error(f'BC: could not reset: {e}')
+        await detector_node.soft_reload()
+    except Exception:
+        logging.exception('BC: could not reset:')
         return False
     return True

learning_loop_node/detector/rest/detect.py

@@ -5,38 +5,39 @@ import numpy as np
 from fastapi import APIRouter, File, Header, Request, UploadFile
 from fastapi.responses import JSONResponse
 
+from ...data_classes.detections import Detections
+
 if TYPE_CHECKING:
     from ..detector_node import DetectorNode
 
-
 router = APIRouter()
 
 
-@router.post("/detect")
+@router.post("/detect", response_model=Detections)
 async def http_detect(
     request: Request,
-    file: UploadFile = File(...),
-    camera_id: Optional[str] = Header(None),
-    mac: Optional[str] = Header(None),
-    tags: Optional[str] = Header(None),
-    source: Optional[str] = Header(None),
-    autoupload: Optional[str] = Header(None),
+    file: UploadFile = File(..., description='The image file to run detection on'),
+    camera_id: Optional[str] = Header(None, description='The camera id (used by learning loop)'),
+    mac: Optional[str] = Header(None, description='The camera mac address (used by learning loop)'),
+    tags: Optional[str] = Header(None, description='Tags to add to the image (used by learning loop)'),
+    source: Optional[str] = Header(None, description='The source of the image (used by learning loop)'),
+    autoupload: Optional[str] = Header(None, description='Mode to decide whether to upload the image to the learning loop',
+                                       examples=['filtered', 'all', 'disabled']),
 ):
     """
-    Example Usage
+    Single image example:
+
+        curl --request POST -F 'file=@test.jpg' localhost:8004/detect -H 'autoupload: all' -H 'camera-id: front_cam' -H 'source: test' -H 'tags: test,test2'
 
-        curl --request POST -F 'file=@test.jpg' localhost:8004/detect
+    Multiple images example:
 
         for i in `seq 1 10`; do time curl --request POST -F 'file=@test.jpg' localhost:8004/detect; done
 
-        You can additionally provide the following camera parameters:
-          - `autoupload`: configures auto-submission to the learning loop; `filtered` (default), `all`, `disabled` (example curl parameter `-H 'autoupload: all'`)
-          - `camera-id`: a string which groups images for submission together (example curl parameter `-H 'camera-id: front_cam'`)
     """
     try:
         np_image = np.fromfile(file.file, np.uint8)
     except Exception as exc:
-        logging.exception(f'Error during reading of image {file.filename}.')
+        logging.exception('Error during reading of image %s.', file.filename)
         raise Exception(f'Uploaded file {file.filename} is no image file.') from exc
 
     try:
@@ -47,6 +48,6 @@ async def http_detect(
                                               source=source,
                                               autoupload=autoupload)
     except Exception as exc:
-        logging.exception(f'Error during detection of image {file.filename}.')
+        logging.exception('Error during detection of image %s.', file.filename)
         raise Exception(f'Error during detection of image {file.filename}.') from exc
-    return JSONResponse(detections)
+    return detections

learning_loop_node/detector/rest/model_version_control.py

@@ -1,7 +1,9 @@
 
 import os
+import sys
+from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
 from fastapi import APIRouter, HTTPException, Request
 
@@ -10,6 +12,7 @@ from ...globals import GLOBALS
 
 if TYPE_CHECKING:
     from ..detector_node import DetectorNode
+KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) else {}
 
 router = APIRouter()
 
@@ -20,9 +23,20 @@ class VersionMode(str, Enum):
     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")
 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
     '''
@@ -35,28 +49,31 @@ async def get_version(request: Request):
     loop_version = app.loop_deployment_target.version if app.loop_deployment_target is not None else 'None'
 
     local_versions: list[str] = []
-
-    local_models = os.listdir(os.path.join(GLOBALS.data_folder, 'models'))
+    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 {
-        'current_version': current_version,
-        'target_version': target_version,
-        'loop_version': loop_version,
-        'local_versions': local_versions,
-        'version_control': app.version_control.value,
-    }
+    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")
 async def put_version(request: Request):
     '''
+    Set the model version control mode.
+
     Example Usage
-        curl -X PUT -d "follow_loop" http://localhost/model_version
-        curl -X PUT -d "pause" http://localhost/model_version
-        curl -X PUT -d "13.6" http://localhost/model_version
+        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')

learning_loop_node/detector/rest/operation_mode.py

@@ -22,7 +22,10 @@ class OperationMode(str, Enum):
 @router.put("/operation_mode")
 async def put_operation_mode(request: Request):
     '''
+    Set the operation mode of the detector node.
+
     Example Usage
+
         curl -X PUT -d "check_for_updates" http://localhost/operation_mode
         curl -X PUT -d "detecting" http://localhost/operation_mode
     '''
@@ -34,22 +37,25 @@ async def put_operation_mode(request: Request):
         raise HTTPException(422, str(exc)) from exc
     node: DetectorNode = request.app
 
-    logging.info(f'current node state : {node.status.state}')
-    logging.info(f'current operation mode : {node.operation_mode.value}')
-    logging.info(f'target operation mode : {target_mode}')
+    logging.info('current node state : %s', node.status.state)
+    logging.info('current operation mode : %s', node.operation_mode.value)
+    logging.info('target operation mode : %s', target_mode)
     if target_mode == node.operation_mode:
         logging.info('operation mode already set')
         return "OK"
 
     await node.set_operation_mode(target_mode)
-    logging.info(f'operation mode set to : {target_mode}')
+    logging.info('operation mode set to : %s', target_mode)
     return "OK"
 
 
-@router.get("/operation_mode")
+@router.get("/operation_mode", response_class=PlainTextResponse)
 async def get_operation_mode(request: Request):
     '''
+    Get the operation mode of the detector node.
+
     Example Usage
+
         curl http://localhost/operation_mode
     '''
     return PlainTextResponse(request.app.operation_mode.value)