learning-loop-node 0.11.0__tar.gz → 0.12.0__tar.gz

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: learning-loop-node
-Version: 0.11.0
+Version: 0.12.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.11.0 → learning_loop_node-0.12.0}/learning_loop_node/data_classes/__init__.py

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

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/data_classes/general.py

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

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/data_classes/image_metadata.py

@@ -28,7 +28,7 @@ class ImageMetadata():
     tags: List[str] = field(default_factory=list, metadata={
         'description': 'List of tags'})
 
-    date: Optional[str] = field(default_factory=current_datetime, metadata={
+    created: Optional[str] = field(default_factory=current_datetime, metadata={
         'description': 'Creation date of the image'})
     source: Optional[str] = field(default=None, metadata={
         'description': 'Source of the image'})

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/data_classes/training.py

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

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/data_exchanger.py

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

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/detector/detector_node.py

@@ -140,7 +140,6 @@ class DetectorNode(Node):
 
         @self.sio.event
         async def detect(sid, data: Dict) -> Dict:
-            self.log.debug('running detect via socketio')
             try:
                 np_image = np.frombuffer(data['image'], np.uint8)
                 det = await self.get_detections(
@@ -153,7 +152,6 @@ 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 detection_dict
             except Exception as e:
                 self.log.exception('could not detect via socketio')
@@ -188,6 +186,9 @@ class DetectorNode(Node):
             source = data.get('source', None)
             creation_date = data.get('creation_date', None)
 
+            self.log.debug('running upload via socketio. tags: %s, source: %s, creation_date: %s',
+                           tags, source, creation_date)
+
             loop = asyncio.get_event_loop()
             try:
                 await loop.run_in_executor(None, self.outbox.save, data['image'], image_metadata, tags, source, creation_date)

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/detector/outbox.py

@@ -76,10 +76,11 @@ class Outbox():
             return
         tmp = f'{GLOBALS.data_folder}/tmp/{identifier}'
         image_metadata.tags = tags
-        if creation_date and self._is_valid_isoformat(creation_date):
-            image_metadata.date = creation_date
+        if self._is_valid_isoformat(creation_date):
+            image_metadata.created = creation_date
         else:
-            image_metadata.date = identifier
+            image_metadata.created = identifier
+
         image_metadata.source = source or 'unknown'
         os.makedirs(tmp, exist_ok=True)
 
@@ -94,7 +95,9 @@ class Outbox():
         else:
             self.log.error('Could not rename %s to %s', tmp, self.path + '/' + identifier)
 
-    def _is_valid_isoformat(self, date: str) -> bool:
+    def _is_valid_isoformat(self, date: Optional[str]) -> bool:
+        if date is None:
+            return False
         try:
             datetime.fromisoformat(date)
             return True
@@ -153,7 +156,7 @@ class Outbox():
             self.log.exception('Could not upload images')
             return
         finally:
-            self.log.info('Closing files')
+            self.log.debug('Closing files')
             for _, file in data:
                 file.close()
 

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/helpers/environment_reader.py

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

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/helpers/log_conf.py

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

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/helpers/misc.py

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

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/loop_communication.py

@@ -35,7 +35,7 @@ class LoopCommunicator():
         else:
             self.async_client = httpx.AsyncClient(base_url=self.base_url, timeout=Timeout(60.0))
 
-        logging.info(f'Loop interface initialized with base_url: {self.base_url} / user: {self.username}')
+        logging.info('Loop interface initialized with base_url: %s / user: %s', self.base_url, self.username)
 
     def websocket_url(self) -> str:
         return f'ws{"s" if "learning-loop.ai" in self.host else ""}://' + self.host
@@ -48,7 +48,7 @@ class LoopCommunicator():
             self.async_client.cookies.clear()
             response = await self.async_client.post('/api/login', data={'username': self.username, 'password': self.password})
             if response.status_code != 200:
-                logging.info(f'Login failed with response: {response}')
+                logging.info('Login failed with response: %s', response)
                 raise LoopCommunicationException('Login failed with response: ' + str(response))
             self.async_client.cookies.update(response.cookies)
 
@@ -57,7 +57,7 @@ class LoopCommunicator():
 
         response = await self.async_client.post('/api/logout')
         if response.status_code != 200:
-            logging.info(f'Logout failed with response: {response}')
+            logging.info('Logout failed with response: %s', response)
             raise LoopCommunicationException('Logout failed with response: ' + str(response))
         self.async_client.cookies.clear()
 
@@ -94,8 +94,7 @@ class LoopCommunicator():
         if requires_login:
             await self.ensure_login()
             return await self.retry_on_401(self._get, path, api_prefix)
-        else:
-            return await self._get(path, api_prefix)
+        return await self._get(path, api_prefix)
 
     async def _get(self, path: str, api_prefix: str) -> httpx.Response:
         return await self.async_client.get(api_prefix+path)
@@ -104,8 +103,7 @@ class LoopCommunicator():
         if requires_login:
             await self.ensure_login()
             return await self.retry_on_401(self._put, path, files, api_prefix, **kwargs)
-        else:
-            return await self._put(path, files, api_prefix, **kwargs)
+        return await self._put(path, files, api_prefix, **kwargs)
 
     async def _put(self, path: str, files: Optional[List[str]], api_prefix: str, **kwargs) -> httpx.Response:
         if files is None:
@@ -133,8 +131,7 @@ class LoopCommunicator():
         if requires_login:
             await self.ensure_login()
             return await self.retry_on_401(self._post, path, api_prefix, **kwargs)
-        else:
-            return await self._post(path, api_prefix, **kwargs)
+        return await self._post(path, api_prefix, **kwargs)
 
     async def _post(self, path, api_prefix='/api', **kwargs) -> httpx.Response:
         return await self.async_client.post(api_prefix+path, **kwargs)
@@ -143,8 +140,7 @@ class LoopCommunicator():
         if requires_login:
             await self.ensure_login()
             return await self.retry_on_401(self._delete, path, api_prefix, **kwargs)
-        else:
-            return await self._delete(path, api_prefix, **kwargs)
+        return await self._delete(path, api_prefix, **kwargs)
 
     async def _delete(self, path, api_prefix, **kwargs) -> httpx.Response:
         return await self.async_client.delete(api_prefix+path, **kwargs)

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/node.py

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

{learning_loop_node-0.11.0 → learning_loop_node-0.12.0}/learning_loop_node/rest.py

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