learning-loop-node 0.9.2__tar.gz → 0.10.0__tar.gz

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learning-loop-node
-Version: 0.9.2
+Version: 0.10.0
 Summary: Python Library for Nodes which connect to the Zauberzeug Learning Loop
 Home-page: https://github.com/zauberzeug/learning_loop_node
 License: MIT

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/learning_loop_node/__init__.py

@@ -1,12 +1,11 @@
 import logging
-import os
-import sys
 
-from .converter.converter_node import ConverterNode
 # from . import log_conf
 from .detector.detector_logic import DetectorLogic
 from .detector.detector_node import DetectorNode
 from .globals import GLOBALS
 from .trainer.trainer_node import TrainerNode
 
+__all__ = ['TrainerNode', 'DetectorNode', 'DetectorLogic', 'GLOBALS']
+
 logging.info('>>>>>>>>>>>>>>>>>> LOOP INITIALIZED <<<<<<<<<<<<<<<<<<<<<<<')

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/learning_loop_node/annotation/annotator_logic.py

@@ -7,10 +7,10 @@ from ..node import Node
 
 class AnnotatorLogic():
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._node: Optional[Node] = None
 
-    def init(self, node: Node):
+    def init(self, node: Node) -> None:
         self._node = node
 
     @abstractmethod

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/learning_loop_node/annotation/annotator_node.py

@@ -8,7 +8,7 @@ from socketio import AsyncClient
 from ..data_classes import AnnotationNodeStatus, Context, NodeState, UserInput
 from ..data_classes.socket_response import SocketResponse
 from ..data_exchanger import DataExchanger
-from ..helpers.misc import create_image_folder
+from ..helpers.misc import create_image_folder, create_project_folder
 from ..node import Node
 from .annotator_logic import AnnotatorLogic
 
@@ -18,10 +18,11 @@ from .annotator_logic import AnnotatorLogic
 class AnnotatorNode(Node):
 
     def __init__(self, name: str, annotator_logic: AnnotatorLogic, uuid: Optional[str] = None):
-        super().__init__(name, uuid)
+        super().__init__(name, uuid, 'annotation_node')
         self.tool = annotator_logic
         self.histories: Dict = {}
         annotator_logic.init(self)
+        self.status_sent = False
 
     def register_sio_events(self, sio_client: AsyncClient):
 
@@ -50,8 +51,6 @@ class AnnotatorNode(Node):
             raise
 
         if tool_result.annotation:
-            if not self.sio_is_initialized():
-                raise Exception('Socket client waas not initialized')
             await self.sio_client.call('update_segmentation_annotation', (user_input.data.context.organization,
                                                                           user_input.data.context.project,
                                                                           jsonable_encoder(asdict(tool_result.annotation))), timeout=30)
@@ -67,6 +66,9 @@ 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,
             name=self.name,
@@ -75,28 +77,27 @@ class AnnotatorNode(Node):
         )
 
         self.log.info(f'Sending status {status}')
-        if self._sio_client is None:
-            raise Exception('No socket client')
-        result = await self._sio_client.call('update_annotation_node', jsonable_encoder(asdict(status)), timeout=10)
+        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)}')
+            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
 
     async def download_image(self, context: Context, uuid: str):
-        project_folder = Node.create_project_folder(context)
+        project_folder = create_project_folder(context)
         images_folder = create_image_folder(project_folder)
 
         downloader = DataExchanger(context=context, loop_communicator=self.loop_communicator)
         await downloader.download_images([uuid], images_folder)
 
-    async def get_state(self):
-        return NodeState.Online
-
-    def get_node_type(self):
-        return 'annotation_node'
-
     async def on_startup(self):
         pass
 
@@ -104,4 +105,4 @@ class AnnotatorNode(Node):
         pass
 
     async def on_repeat(self):
-        pass
+        await self.send_status()

learning_loop_node-0.10.0/learning_loop_node/data_classes/__init__.py

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

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/learning_loop_node/data_classes/detections.py

@@ -13,8 +13,11 @@ KWONLY_SLOTS = {'kw_only': True, 'slots': True} if sys.version_info >= (3, 10) e
 
 @dataclass(**KWONLY_SLOTS)
 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  # TODO add definition of x,y,w,h
+    x: int
     y: int
     width: int
     height: int
@@ -47,6 +50,8 @@ class BoxDetection():
 
 @dataclass(**KWONLY_SLOTS)
 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
@@ -111,7 +116,7 @@ class Detections():
     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: Optional[List[str]] = field(default_factory=list)
+    tags: List[str] = field(default_factory=list)
     date: Optional[str] = field(default_factory=current_datetime)
     image_id: Optional[str] = None  # used for detection of trainers
 

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/learning_loop_node/data_classes/general.py

@@ -34,10 +34,6 @@ class Category():
         return [from_dict(data_class=Category, data=value) for value in values]
 
 
-def create_category(identifier: str, name: str, ctype: Union[CategoryType, str]):  # TODO: This is probably unused
-    return Category(id=identifier, name=name, description='', hotkey='', color='', type=ctype, point_size=None)
-
-
 @dataclass(**KWONLY_SLOTS)
 class Context():
     organization: str
@@ -57,6 +53,7 @@ class ModelInformation():
     categories: List[Category]
     resolution: Optional[int] = None
     model_root_path: Optional[str] = None
+    model_size: Optional[str] = None
 
     @property
     def context(self):
@@ -64,6 +61,8 @@ class ModelInformation():
 
     @staticmethod
     def load_from_disk(model_root_path: str) -> Optional['ModelInformation']:
+        """Load model.json from model_root_path and return ModelInformation object.
+        """
         model_info_file_path = f'{model_root_path}/model.json'
         if not os.path.exists(model_info_file_path):
             logging.warning(f"could not find model information file '{model_info_file_path}'")
@@ -90,6 +89,10 @@ class ModelInformation():
             del self_as_dict['model_root_path']
             f.write(json.dumps(self_as_dict))
 
+    @staticmethod
+    def from_dict(data: Dict) -> 'ModelInformation':
+        return from_dict(ModelInformation, data=data)
+
 
 @dataclass(**KWONLY_SLOTS)
 class ErrorConfiguration():
@@ -117,7 +120,7 @@ class NodeState(str, Enum):
 class NodeStatus():
     id: str
     name: str
-    state: Optional[NodeState] = NodeState.Offline
+    state: Optional[NodeState] = NodeState.Online
     uptime: Optional[int] = 0
     errors: Dict = field(default_factory=dict)
     capabilities: List[str] = field(default_factory=list)

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/learning_loop_node/data_classes/training.py

@@ -1,8 +1,10 @@
 
 import sys
+import time
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Dict, List, Optional, Union
+from pathlib import Path
+from typing import Dict, List, Optional
 
 # pylint: disable=no-name-in-module
 from .general import Category, Context
@@ -16,6 +18,14 @@ class Hyperparameter():
     flip_rl: bool
     flip_ud: bool
 
+    @staticmethod
+    def from_data(data: Dict):
+        return Hyperparameter(
+            resolution=data['resolution'],
+            flip_rl=data.get('flip_rl', False),
+            flip_ud=data.get('flip_ud', False)
+        )
+
 
 @dataclass(**KWONLY_SLOTS)
 class TrainingData():
@@ -41,14 +51,15 @@ class PretrainedModel():
     description: str
 
 
-class TrainingState(str, 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 = 'training_running'
+    TrainingRunning = 'running'
     TrainingFinished = 'training_finished'
     ConfusionMatrixSyncing = 'confusion_matrix_syncing'
     ConfusionMatrixSynced = 'confusion_matrix_synced'
@@ -62,9 +73,9 @@ class TrainingState(str, Enum):
 
 @dataclass(**KWONLY_SLOTS)
 class TrainingStatus():
-    id: str  # TODO this must not be changed, but tests wont detect it -> update tests!
+    id: str  # NOTE this must not be changed, but tests wont detect a change -> update tests!
     name: str
-    state: Union[Optional[TrainingState], str]
+    state: Optional[str]
     errors: Optional[Dict]
     uptime: Optional[float]
     progress: Optional[float]
@@ -77,13 +88,13 @@ class TrainingStatus():
     architecture: Optional[str] = None
     context: Optional[Context] = None
 
-    def short_str(self):
+    def short_str(self) -> str:
         prgr = f'{self.progress * 100:.0f}%' if self.progress else ''
         trtesk = f'{self.train_image_count}/{self.test_image_count}/{self.skipped_image_count}' if self.train_image_count else 'n.a.'
         cntxt = f'{self.context.organization}/{self.context.project}' if self.context else ''
         hyps = f'({self.hyperparameters})' if self.hyperparameters else ''
         arch = f'.{self.architecture} - ' if self.architecture else ''
-        return f'[{str(self.state)} {prgr}. {self.name}({self.id}). Tr/Ts/Tsk: {trtesk} {cntxt}{arch}{hyps}]'
+        return f'[{str(self.state).rsplit(".", maxsplit=1)[-1]} {prgr}. {self.name}({self.id}). Tr/Ts/Tsk: {trtesk} {cntxt}{arch}{hyps}]'
 
 
 @dataclass(**KWONLY_SLOTS)
@@ -91,21 +102,35 @@ class Training():
     id: str
     context: Context
 
-    project_folder: str
-    images_folder: str
-    training_folder: str
+    project_folder: str  # f'{GLOBALS.data_folder}/{context.organization}/{context.project}'
+    images_folder: str  # f'{project_folder}/images'
+    training_folder: str  # f'{project_folder}/trainings/{trainings_id}'
+    start_time: float = field(default_factory=time.time)
+
+    # model uuid to download (to continue training) | is not a uuid when training from scratch (blank or pt-name from provided_pretrained_models->name)
+    base_model_uuid_or_name: Optional[str] = None
 
-    base_model_id: Optional[str] = None
     data: Optional[TrainingData] = None
     training_number: Optional[int] = None
-    training_state: Optional[Union[TrainingState, str]] = None
-    model_id_for_detecting: Optional[str] = None
+    training_state: Optional[str] = None
+    model_uuid_for_detecting: Optional[str] = None
     hyperparameters: Optional[Dict] = None
 
+    @property
+    def training_folder_path(self) -> Path:
+        return Path(self.training_folder)
+
+    def set_values_from_data(self, data: Dict) -> None:
+        self.data = TrainingData(categories=Category.from_list(data['categories']))
+        self.data.hyperparameter = Hyperparameter.from_data(data=data)
+        self.training_number = data['training_number']
+        self.base_model_uuid_or_name = data['id']
+        self.training_state = TrainerState.Initialized
+
 
 @dataclass(**KWONLY_SLOTS)
 class TrainingOut():
-    confusion_matrix: Optional[Dict] = None
+    confusion_matrix: Optional[Dict] = None  # This is actually just class-wise metrics
     train_image_count: Optional[int] = None
     test_image_count: Optional[int] = None
     trainer_id: Optional[str] = None
@@ -113,9 +138,9 @@ class TrainingOut():
 
 
 @dataclass(**KWONLY_SLOTS)
-class BasicModel():
-    confusion_matrix: Optional[Dict] = None
-    meta_information: Optional[Dict] = None
+class TrainingStateData():
+    confusion_matrix: Dict = field(default_factory=dict)
+    meta_information: Dict = field(default_factory=dict)
 
 
 @dataclass(**KWONLY_SLOTS)
@@ -130,8 +155,8 @@ class Model():
 
 
 class Errors():
-    def __init__(self):
-        self._errors: Dict = {}
+    def __init__(self) -> None:
+        self._errors: Dict[str, str] = {}
 
     def set(self, key: str, value: str):
         self._errors[key] = value
@@ -140,7 +165,7 @@ class Errors():
     def errors(self) -> Dict:
         return self._errors
 
-    def reset(self, key: str):
+    def reset(self, key: str) -> None:
         try:
             del self._errors[key]
         except AttributeError:
@@ -148,7 +173,7 @@ class Errors():
         except KeyError:
             pass
 
-    def reset_all(self):
+    def reset_all(self) -> None:
         self._errors = {}
 
     def has_error_for(self, key: str) -> bool:
@@ -162,3 +187,6 @@ class TrainingError(Exception):
     def __init__(self, cause: str, *args: object) -> None:
         super().__init__(*args)
         self.cause = cause
+
+    def __str__(self) -> str:
+        return f'TrainingError: {self.cause}'

learning_loop_node-0.10.0/learning_loop_node/data_exchanger.py

@@ -0,0 +1,172 @@
+import asyncio
+import logging
+import os
+import shutil
+import zipfile
+from glob import glob
+from http import HTTPStatus
+from io import BytesIO
+from time import time
+from typing import Dict, List, Optional
+
+import aiofiles  # type: ignore
+
+from .data_classes import Context
+from .helpers.misc import create_resource_paths, create_task, is_valid_image
+from .loop_communication import LoopCommunicator
+
+
+class DownloadError(Exception):
+
+    def __init__(self, cause: str, *args: object) -> None:
+        super().__init__(*args)
+        self.cause = cause
+
+    def __str__(self) -> str:
+        return f'DownloadError: {self.cause}'
+
+
+class DataExchanger():
+
+    def __init__(self, context: Optional[Context], loop_communicator: LoopCommunicator):
+        """Exchanges data with the learning loop via the loop_communicator (rest api).
+
+        Args:
+            context (Optional[Context]): The context of the node. This is the organization and project name.
+            loop_communicator (LoopCommunicator): The loop_communicator to use for communication with the learning loop.
+
+        Note:
+            The context can be set later with the set_context method.
+        """
+        self.set_context(context)
+        self.progress = 0.0
+        self.loop_communicator = loop_communicator
+
+        self.check_jpeg = shutil.which('jpeginfo') is not None
+        if self.check_jpeg:
+            logging.info('Detected command line tool "jpeginfo". Images will be checked for validity')
+        else:
+            logging.error('Missing command line tool "jpeginfo". We cannot check for validity of images.')
+
+    def set_context(self, context: Optional[Context]) -> None:
+        self._context = context
+        self.progress = 0.0
+
+    @property
+    def context(self) -> Context:
+        assert self._context, 'DataExchanger: Context was not set yet.. call set_context() first.'
+        return self._context
+
+    # ---------------------------- END OF INIT ----------------------------
+
+    async def fetch_image_uuids(self, query_params: Optional[str] = '') -> List[str]:
+        """Fetch image uuids from the learning loop data endpoint."""
+        logging.info(f'Fetching image uuids for {self.context.organization}/{self.context.project}..')
+
+        response = await self.loop_communicator.get(f'/{self.context.organization}/projects/{self.context.project}/data?{query_params}')
+        assert response.status_code == 200, response
+        return (response.json())['image_ids']
+
+    async def download_images_data(self, image_uuids: List[str], chunk_size: int = 100) -> List[Dict]:
+        """Download image annotations, tags, set and other information for the given image uuids."""
+        logging.info(f'Fetching annotations, tags, sets, etc. for {len(image_uuids)} images..')
+
+        num_image_ids = len(image_uuids)
+        if num_image_ids == 0:
+            logging.info('got empty list. No images were downloaded')
+            return []
+
+        progress_factor = 0.5 / num_image_ids  # 50% of progress is for downloading data
+        images_data: List[Dict] = []
+        for i in range(0, num_image_ids, chunk_size):
+            self.progress = i * progress_factor
+            chunk_ids = image_uuids[i:i+chunk_size]
+            response = await self.loop_communicator.get(f'/{self.context.organization}/projects/{self.context.project}/images?ids={",".join(chunk_ids)}')
+            if response.status_code != 200:
+                logging.error(f'Error {response.status_code} during downloading image data. Continue with next batch..')
+                continue
+            images_data += response.json()['images']
+
+        return images_data
+
+    async def download_images(self, image_uuids: List[str], image_folder: str, chunk_size: int = 10) -> None:
+        """Downloads images (actual image data). Will skip existing images"""
+        logging.info(f'Downloading {len(image_uuids)} images (actual image data).. skipping existing images.')
+        if not image_uuids:
+            return
+
+        existing_uuids = {os.path.splitext(os.path.basename(image))[0] for image in glob(f'{image_folder}/*.jpg')}
+        new_image_uuids = [id for id in image_uuids if id not in existing_uuids]
+
+        paths, _ = create_resource_paths(self.context.organization, self.context.project, new_image_uuids)
+        num_image_ids = len(image_uuids)
+        os.makedirs(image_folder, exist_ok=True)
+
+        progress_factor = 0.5 / num_image_ids  # second 50% of progress is for downloading images
+        for i in range(0, num_image_ids, chunk_size):
+            self.progress = 0.5 + i * progress_factor
+            chunk_paths = paths[i:i+chunk_size]
+            chunk_ids = image_uuids[i:i+chunk_size]
+            tasks = []
+            for j, chunk_j in enumerate(chunk_paths):
+                start = time()
+                tasks.append(create_task(self._download_one_image(chunk_j, chunk_ids[j], image_folder)))
+                await asyncio.sleep(max(0, 0.02 - (time() - start)))  # prevent too many requests at once
+            await asyncio.gather(*tasks)
+
+    async def _download_one_image(self, path: str, image_id: str, image_folder: str) -> None:
+        response = await self.loop_communicator.get(path)
+        if response.status_code != HTTPStatus.OK:
+            logging.error(f'bad status code {response.status_code} for {path}. Details: {response.text}')
+            return
+        filename = f'{image_folder}/{image_id}.jpg'
+        async with aiofiles.open(filename, 'wb') as f:
+            await f.write(response.content)
+        if not await is_valid_image(filename, self.check_jpeg):
+            os.remove(filename)
+
+    async def download_model(self, target_folder: str, context: Context, model_uuid: str, model_format: str) -> List[str]:
+        """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}..')
+
+        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'])
+        try:
+            provided_filename = response.headers.get(
+                "Content-Disposition").split("filename=")[1].strip('"')
+            content = response.content
+        except:
+            logging.exception(f'Error during downloading model {path}:')
+            raise
+
+        tmp_path = f'/tmp/{os.path.splitext(provided_filename)[0]}'
+        shutil.rmtree(tmp_path, ignore_errors=True)
+        with zipfile.ZipFile(BytesIO(content), 'r') as zip_:
+            zip_.extractall(tmp_path)
+
+        created_files = []
+        for file in glob(f'{tmp_path}/**/*', recursive=True):
+            new_file = shutil.move(file, target_folder)
+            created_files.append(new_file)
+
+        shutil.rmtree(tmp_path, ignore_errors=True)
+        logging.info(f'Downloaded model {model_uuid}({model_format}) to {target_folder}.')
+        return created_files
+
+    async def upload_model_get_uuid(self, context: Context, files: List[str], training_number: Optional[int], mformat: str) -> Optional[str]:
+        """Used by the trainers. Function returns the new model uuid to use for detection."""
+        response = await self.loop_communicator.put(f'/{context.organization}/projects/{context.project}/trainings/{training_number}/models/latest/{mformat}/file', files=files)
+        if response.status_code != 200:
+            logging.error(f'Could not upload model for training {training_number}, format {mformat}: {response.text}')
+            response.raise_for_status()
+            return None
+
+        uploaded_model = response.json()
+        logging.info(f'Uploaded model for training {training_number}, format {mformat}. Response is: {uploaded_model}')
+        return uploaded_model['id']

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/learning_loop_node/detector/detector_logic.py

@@ -13,11 +13,9 @@ class DetectorLogic():
     def __init__(self, model_format: str) -> None:
         self.model_format: str = model_format
         self._model_info: Optional[ModelInformation] = None
-        self.target_model: Optional[str] = None
 
     async def soft_reload(self):
         self._model_info = None
-        self.target_model = None
 
     @property
     def model_info(self) -> ModelInformation:

{learning_loop_node-0.9.2 → learning_loop_node-0.10.0}/learning_loop_node/detector/detector_node.py

@@ -14,8 +14,7 @@ from fastapi.encoders import jsonable_encoder
 from fastapi_socketio import SocketManager
 from socketio import AsyncClient
 
-from ..data_classes import (Category, Context, Detections, DetectionStatus,
-                            ModelInformation, NodeState, Shape)
+from ..data_classes import Category, Context, Detections, DetectionStatus, ModelInformation, Shape
 from ..data_classes.socket_response import SocketResponse
 from ..data_exchanger import DataExchanger, DownloadError
 from ..globals import GLOBALS
@@ -24,6 +23,7 @@ from ..node import Node
 from .detector_logic import DetectorLogic
 from .inbox_filter.relevance_filter import RelevanceFilter
 from .outbox import Outbox
+from .rest import about as rest_about
 from .rest import backdoor_controls
 from .rest import detect as rest_detect
 from .rest import operation_mode as rest_mode
@@ -34,9 +34,8 @@ from .rest.operation_mode import OperationMode
 class DetectorNode(Node):
 
     def __init__(self, name: str, detector: DetectorLogic, uuid: Optional[str] = None, use_backdoor_controls: bool = False) -> None:
-        super().__init__(name, uuid)
+        super().__init__(name, uuid, 'detector', False)
         self.detector_logic = detector
-        self.needs_login = False
         self.organization = environment_reader.organization()
         self.project = environment_reader.project()
         assert self.organization and self.project, 'Detector node needs an organization and an project'
@@ -50,11 +49,13 @@ class DetectorNode(Node):
             self.loop_communicator)
 
         self.relevance_filter: RelevanceFilter = RelevanceFilter(self.outbox)
-        self.target_model = None
+        self.target_model: Optional[str] = None
 
         self.include_router(rest_detect.router, tags=["detect"])
         self.include_router(rest_upload.router, prefix="")
         self.include_router(rest_mode.router, tags=["operation_mode"])
+        self.include_router(rest_about.router, tags=["about"])
+
         if use_backdoor_controls:
             self.include_router(backdoor_controls.router)
 
@@ -168,6 +169,8 @@ class DetectorNode(Node):
         def _connect(sid, environ, auth) -> None:
             self.connected_clients.append(sid)
 
+        print('>>>>>>>>>>>>>>>>>>>>>>> setting up sio server', flush=True)
+
         self.sio_server = SocketManager(app=self)
         self.sio_server.on('detect', _detect)
         self.sio_server.on('info', _info)
@@ -183,7 +186,9 @@ class DetectorNode(Node):
             if not update_to_model_id:
                 self.log.info('could not check for updates')
                 return
-            if self.detector_logic.is_initialized:  # TODO: solve race condition !!!
+
+            # TODO: solve race condition (it should not be required to recheck if model_info is not None, but it is!)
+            if self.detector_logic.is_initialized:
                 model_info = self.detector_logic._model_info  # pylint: disable=protected-access
                 if model_info is not None:
                     self.log.info(f'Current model: {model_info.version} with id {model_info.id}')
@@ -218,8 +223,7 @@ class DetectorNode(Node):
                     await self.data_exchanger.download_model(target_model_folder,
                                                              Context(organization=self.organization,
                                                                      project=self.project),
-                                                             update_to_model_id,
-                                                             self.detector_logic.model_format)
+                                                             update_to_model_id, self.detector_logic.model_format)
                     try:
                         os.unlink(model_symlink)
                         os.remove(model_symlink)
@@ -254,7 +258,7 @@ class DetectorNode(Node):
             name=self.name,
             state=self.status.state,
             errors=self.status.errors,
-            uptime=int((datetime.now() - self.startup_time).total_seconds()),
+            uptime=int((datetime.now() - self.startup_datetime).total_seconds()),
             operation_mode=self.operation_mode,
             current_model=current_model,
             target_model=self.target_model,
@@ -270,13 +274,11 @@ class DetectorNode(Node):
             return False
 
         assert socket_response.payload is not None
+        # TODO This is weird because target_model_version is stored in self and target_model_id is returned
         self.target_model = socket_response.payload['target_model_version']
         self.log.info(f'After sending status. Target_model is {self.target_model}')
         return socket_response.payload['target_model_id']
 
-    async def get_state(self):
-        return NodeState.Online  # NOTE At the moment only trainer-nodes use a meaningful state
-
     async def set_operation_mode(self, mode: OperationMode):
         self.operation_mode = mode
         await self.send_status()
@@ -351,9 +353,6 @@ class DetectorNode(Node):
             classification_detection.category_id = category_id
         return detections
 
-    def get_node_type(self):
-        return 'detector'
-
     def register_sio_events(self, sio_client: AsyncClient):
         pass