tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

tomwer/app/zstitching.py

@@ -1,380 +1,25 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+"""
+Application to stitch along z (aka axis 0) a set of scans or reconstructed volumes
+"""
+from __future__ import annotations
 
-import argparse
-import logging
-import signal
 import sys
-import functools
-
-import silx
-from silx.gui import qt
-
-from nabu.utils import Progress
-from nabu.stitching.config import StitchingType
-
-from tomwer.core.settings import SlurmSettingsMode
-from tomwer.core.utils.resource import increase_max_number_file
-from tomwer.gui import icons
-from tomwer.core.process.stitching.nabustitcher import StitcherTask
-from tomwer.io.utils.tomoobj import get_tomo_objs_instances
-from tomwer.gui.utils.splashscreen import getMainSplashScreen
-from tomwer.gui.stitching.stitching import ZStitchingWindow as _ZStitchingWindow
-from tomwer.gui.stitching import action as stitching_action
-from tomwer.gui.cluster.slurm import SlurmSettingsWidget
-from tomwer.core.scan.scanbase import TomwerScanBase
+import logging
+from tomwer.app.stitching.common import main as common_main
 
 logging.basicConfig(level=logging.WARNING)
 
 _logger = logging.getLogger(__name__)
 
 
-class MainWidget(qt.QTabWidget):
-    DEFAULT_NB_WORKERS = 10
-
-    def __init__(
-        self,
-        parent=None,
-    ) -> None:
-        super().__init__(parent)
-        self._stitchingConfigWindow = _ZStitchingWindow(
-            parent=self, with_configuration_action=False
-        )
-        self.addTab(self._stitchingConfigWindow, "stitching config")
-        settingsClass = SlurmSettingsMode.get_settings_class(
-            SlurmSettingsMode.STITCHING
-        )
-        self._slurmConfig = SlurmSettingsWidget(
-            parent=self, n_gpu=settingsClass.N_GPUS_PER_WORKER, jobLimitation=None
-        )
-        self._slurmConfig.setConfiguration(
-            {
-                "cpu-per-task": settingsClass.N_CORES_PER_TASK,
-                "n_tasks": settingsClass.N_TASKS,
-                "n_jobs": settingsClass.N_JOBS,
-                "memory": settingsClass.MEMORY_PER_WORKER,
-                "partition": settingsClass.PARTITION,
-                "n_gpus": settingsClass.N_GPUS_PER_WORKER,
-                "job_name": settingsClass.PROJECT_NAME,
-                "python_venv": settingsClass.PYTHON_VENV,
-            }
-        )
-
-        self._stitchingConfigWindow.setCallbackToGetSlurmConfig(
-            self._slurmConfig.getConfiguration
-        )
-        self._stitchingConfigWindow.setCallbackToSetSlurmConfig(
-            self._slurmConfig.setConfiguration
-        )
-        self.addTab(self._slurmConfig, "slurm config")
-        # add an option to clearly activate / deactivate slurm config
-        slurm_config_idx = self.indexOf(self._slurmConfig)
-        self._slurmCB = qt.QCheckBox(self)
-        self.tabBar().setTabButton(
-            slurm_config_idx,
-            qt.QTabBar.LeftSide,
-            self._slurmCB,
-        )
-        self._slurmCB.setChecked(True)
-
-        # set up
-        self._slurmConfig.setNWorkers(self.DEFAULT_NB_WORKERS)
-
-    def close(self):
-        self._stitchingConfigWindow.close()
-        # requested for the waiting plot update
-        super().close()
-
-    def keyPressEvent(self, event):
-        """
-        To shortcut orange and make sure the `F5` <=> refresh stitching preview
-        """
-        modifiers = event.modifiers()
-        key = event.key()
-
-        if key == qt.Qt.Key_F5:
-            self._stitchingConfigWindow._trigger_update_preview()
-        elif key == qt.Qt.Key_O and modifiers == qt.Qt.KeyboardModifier.ControlModifier:
-            self._stitchingConfigWindow._loadSettings()
-        elif key == qt.Qt.Key_S and modifiers == qt.Qt.KeyboardModifier.ControlModifier:
-            self._stitchingConfigWindow._saveSettings()
-
-    def getStitchingConfiguration(self) -> dict:
-        return self._stitchingConfigWindow.getConfiguration()
-
-    def getClusterConfig(self) -> dict:
-        return self._slurmConfig.getConfiguration()
-
-    # expose API
-    def addTomoObj(self, *args, **kwargs):
-        self._stitchingConfigWindow.addTomoObj(*args, **kwargs)
-
-    def setStitchingType(self, stitching_type):
-        self._stitchingConfigWindow.setStitchingType(stitching_type)
-
-    def loadSettings(self, config_file):
-        self._stitchingConfigWindow._loadSettings(config_file)
-
-
-class _StitcherThread(qt.QThread):
-    def __init__(self, parent, stitching_config, cluster_config) -> None:
-        super().__init__(parent)
-        assert isinstance(stitching_config, dict)
-        assert isinstance(cluster_config, dict)
-        self._stitching_config = stitching_config
-        self._cluster_config = cluster_config
-
-    def run(self):
-        task = StitcherTask(
-            inputs={
-                "stitching_config": self._stitching_config,
-                "cluster_config": self._cluster_config,
-                "progress": Progress("stitching"),
-                "serialize_output_data": False,
-            },
-        )
-
-        if self._cluster_config in (None, {}):
-            self._runLocally(task)
-        else:
-            self._runRemotly(task)
-
-    def _runLocally(self, task):
-        task.run()
-
-    def _runRemotly(self, task):
-        task.run()
-        # wait for processing to be finished
-        for future in task.outputs.future_tomo_obj.futures:
-            future.result()
-        # note: there is also a callback to aggregate result once all are finished.
-        # so at this stage the final "nxtomo" or "volume" might not exists yet
-        print("Add slurm job finished.")
-
-
-class MainWindow(qt.QDialog):
-    def __init__(self, parent=None) -> None:
-        super().__init__(parent)
-        self.setLayout(qt.QVBoxLayout())
-        # menu
-        self._menuBar = qt.QMenuBar(self)
-        self.layout().addWidget(self._menuBar)
-        self._menu = qt.QMenu("&Stitching")
-        self._menuBar.addMenu(self._menu)
-        # save / load configuration
-        self._loadConfigurationAction = stitching_action.LoadConfigurationAction(
-            self, "&Load configuration"
-        )
-        self._menu.addAction(self._loadConfigurationAction)
-        self._saveConfigurationAction = stitching_action.SaveConfigurationAction(
-            self, "&Save configuration"
-        )
-        self._menu.addAction(self._saveConfigurationAction)
-        # separator
-        self._menu.addSeparator()
-        # add tomo object
-        self._addTomoObjectAction = stitching_action.AddTomoObjectAction(
-            self, "&Add tomo object (volume or NXtomo)"
-        )
-        self._menu.addAction(self._addTomoObjectAction)
-
-        # main window
-        self.setWindowTitle("tomwer z-stitching")
-        self._mainWindow = MainWidget(parent=self)
-        self.layout().addWidget(self._mainWindow)
-
-        # button
-        types = qt.QDialogButtonBox.Apply
-        self._buttons = qt.QDialogButtonBox(self)
-        self._buttons.setStandardButtons(types)
-        self.layout().addWidget(self._buttons)
-        self._buttons.button(qt.QDialogButtonBox.Apply).setText("Launch stitching")
-
-        # connect signal / slot
-        self._buttons.button(qt.QDialogButtonBox.Apply).clicked.connect(self.accept)
-        self._loadConfigurationAction.triggered.connect(
-            functools.partial(
-                self._mainWindow._stitchingConfigWindow._loadSettings, file_path=None
-            )
-        )
-        self._saveConfigurationAction.triggered.connect(
-            functools.partial(
-                self._mainWindow._stitchingConfigWindow._saveSettings, file_path=None
-            )
-        )
-        self._addTomoObjectAction.triggered.connect(self._callbackAddTomoObj)
-
-    def _callbackAddTomoObj(self, *args, **kwargs):
-        """move interface to the z-ordered list and call the 'add tomo obj' callback"""
-        orderedListWidget = (
-            self._mainWindow._stitchingConfigWindow._widget._mainWidget._zOrderedList
-        )
-        self._mainWindow._stitchingConfigWindow._widget._mainWidget.setCurrentWidget(
-            orderedListWidget
-        )
-        orderedListWidget._callbackAddTomoObj()
-
-    def close(self):
-        self._mainWindow.close()
-        # requested for the waiting plot update
-        super().close()
-
-    def reject(self):
-        self.close()
-        super().reject()
-
-    def accept(self):
-        self.process_stitching()
-
-    def process_stitching(self):
-        self._processingThread = _StitcherThread(
-            parent=self,
-            stitching_config=self.getStitchingConfiguration(),
-            cluster_config=self.getClusterConfig(),
-        )
-        self._processingThread.start()
-
-    def disableSlurmconfig(self):
-        self._mainWindow._slurmCB.setChecked(False)
-        self._mainWindow._slurmCB.setCheckable(False)
-
-        slurm_config_idx = self._mainWindow.indexOf(self._mainWindow._slurmConfig)
-
-        self._mainWindow.setTabEnabled(
-            slurm_config_idx,
-            False,
-        )
-        self._mainWindow.setTabToolTip(
-            slurm_config_idx,
-            "not available because unable to find slurm command (computer is probably not a slurm client ?",
-        )
-
-    # expose API
-    def addTomoObj(self, *args, **kwargs):
-        self._mainWindow.addTomoObj(*args, **kwargs)
-
-    def getClusterConfig(self) -> dict:
-        if self._mainWindow._slurmCB.isChecked():
-            return self._mainWindow.getClusterConfig()
-        else:
-            return {}
-
-    def getStitchingConfiguration(self) -> dict:
-        return self._mainWindow.getStitchingConfiguration()
-
-    def setStitchingType(self, stitching_type):
-        self._mainWindow.setStitchingType(stitching_type)
-
-    def loadSettings(self, config_file: str):
-        self._mainWindow.loadSettings(config_file)
-
-
-def main(argv):
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "tomo_objs",
-        help="All tomo objects to be stitched together",
-        nargs="*",
-    )
-    parser.add_argument(
-        "--debug",
-        dest="debug",
-        action="store_true",
-        default=False,
-        help="Set logging system in debug mode",
-    )
-
-    parser.add_argument(
-        "--config",
-        "--config-file",
-        dest="config_file",
-        default=None,
-        help="Provide stitching configuration file to load parameters from it",
-    )
-    parser.add_argument(
-        "--use-opengl-plot",
-        help="Use OpenGL for plots (instead of matplotlib)",
-        action="store_true",
-        default=False,
-    )
-    parser.add_argument(
-        "--check-scans",
-        help="If True will check scans before adding them. This check scan validity (virtual dataset contains data...)",
-        action="store_true",
-        default=False,
-    )
-    options = parser.parse_args(argv[1:])
-
-    if options.use_opengl_plot:
-        silx.config.DEFAULT_PLOT_BACKEND = "gl"
-    else:
-        silx.config.DEFAULT_PLOT_BACKEND = "matplotlib"
-
-    if options.debug:
-        logging.root.setLevel(logging.DEBUG)
-
-    increase_max_number_file()
-
-    global app  # QApplication must be global to avoid seg fault on quit
-    app = qt.QApplication.instance() or qt.QApplication(["tomwer"])
-    splash = getMainSplashScreen()
-    qt.QApplication.processEvents()
-
-    qt.QLocale.setDefault(qt.QLocale(qt.QLocale.English))
-    qt.QLocale.setDefault(qt.QLocale.c())
-    signal.signal(signal.SIGINT, sigintHandler)
-    sys.excepthook = qt.exceptionHandler
-
-    timer = qt.QTimer()
-    timer.start(500)
-    # Application have to wake up Python interpreter, else SIGINT is not
-    # catch
-    timer.timeout.connect(lambda: None)
-
-    window = MainWindow()
-    window.setWindowFlags(qt.Qt.Window)
-    window.setWindowTitle("tomwer: z-stitching")
-    window.setWindowIcon(icons.getQIcon("tomwer"))
-
-    window.show()
-    from sluurp.utils import has_sbatch_available
-
-    # load configuration is some provided
-    if options.config_file is not None:
-        window.loadSettings(options.config_file)
-
-    if not has_sbatch_available():
-        window.disableSlurmconfig()
-
-    tomo_objs, (has_scans, has_vols) = get_tomo_objs_instances(options.tomo_objs)
-    for tomo_obj in tomo_objs:
-        if isinstance(tomo_obj, TomwerScanBase):
-            tomo_obj.set_check_behavior(
-                run_check=options.check_scans
-            )  # speed up processing
-        window.addTomoObj(tomo_obj=tomo_obj)
-    if has_scans and has_vols:
-        _logger.warning(
-            "seems like you have both volumes and scan on your inputs. Unable to stitch the two at the same time"
-        )
-    elif has_scans:
-        window.setStitchingType(StitchingType.Z_PREPROC)
-    elif has_vols:
-        window.setStitchingType(StitchingType.Z_POSTPROC)
-
-    window.setAttribute(qt.Qt.WA_DeleteOnClose)
-    splash.finish(window)
-    exit(app.exec_())
-
-
 def getinputinfo():
     return "tomwer z-stitching [tomo objects]"
 
 
-def sigintHandler(*args):
-    """Handler for the SIGINT signal."""
-    qt.QApplication.closeAllWindows()  # needed because get a waiting thread behind
-    qt.QApplication.quit()
+def main(argv):
+    common_main(argv, stitcher_name="z-stitching", stitching_axis=0, logger=_logger)
 
 
 if __name__ == "__main__":

tomwer/core/__init__.py

@@ -1,28 +1,2 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__author__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "02/06/2017"
+"""This package contains all the core functions / classes of tomwer
+"""

tomwer/core/cluster/__init__.py

@@ -1 +1,4 @@
+"""cluster related functions and classes (slurm...)
+"""
+
 from .cluster import SlurmClusterConfiguration  # noqa F401

tomwer/core/cluster/cluster.py

@@ -1,35 +1,10 @@
 # coding: utf-8
-# /*##########################################################################
-# Copyright (C) 2017-2021 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-#############################################################################*/
 
 """
 Contains processing relative to a `Slurmcluster`
 """
 
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "12/10/2021"
-
+from __future__ import annotations
 
 import logging
 from tomwer.core.settings import SlurmSettings as _SlurmSettings
@@ -48,6 +23,7 @@ class SlurmClusterConfiguration:
         queue=_SlurmSettings.PARTITION,
         n_gpus=_SlurmSettings.N_GPUS_PER_WORKER,
         project_name=_SlurmSettings.PROJECT_NAME,
+        walltime=_SlurmSettings.DEFAULT_WALLTIME,
         python_venv=_SlurmSettings.PYTHON_VENV,
         n_jobs=_SlurmSettings.N_JOBS,
         modules_to_load: tuple = _SlurmSettings.MODULES_TO_LOAD,
@@ -59,6 +35,7 @@ class SlurmClusterConfiguration:
         self._queue = queue
         self._n_gpus = n_gpus
         self._project_name = project_name
+        self._walltime = walltime
         self._python_venv = python_venv
         self._modules_to_load = modules_to_load
         self._n_jobs = n_jobs
@@ -96,6 +73,10 @@ class SlurmClusterConfiguration:
     def project_name(self):
         return self._project_name
 
+    @property
+    def walltime(self):
+        return self._walltime
+
     @property
     def python_venv(self):
         return self._python_venv
@@ -126,6 +107,7 @@ class SlurmClusterConfiguration:
             "partition": self.queue,
             "n_gpus": self.n_gpus,
             "job_name": self.project_name,
+            "walltime": self.walltime,
             "python_venv": self.python_venv,
             "modules": self.modules_to_load,
             "sbatch_extra_params": self.sbatch_extra_params,
@@ -150,6 +132,8 @@ class SlurmClusterConfiguration:
             self._n_gpus = dict_["n_gpus"]
         if "job_name" in dict_:
             self._project_name = dict_["job_name"]
+        if "walltime" in dict_:
+            self._walltime = dict_["walltime"]
         if "python_venv" in dict_:
             self._python_venv = dict_["python_venv"]
         modules = dict_.get("modules", None)

tomwer/core/futureobject.py

@@ -1,36 +1,11 @@
-# coding: utf-8
-# /*##########################################################################
-# Copyright (C) 2016 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-#############################################################################*/
-
-
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "09/10/2021"
+"""contains 'FutureTomwerObject'. Class used when computation is done asynchronously (when submitted to slurm for example)
+"""
 
+from __future__ import annotations
 
 import datetime
 import logging
-from typing import Iterable, Optional, Union
+from typing import Iterable
 
 from sluurp.job import get_job_status, cancel_slurm_job
 
@@ -44,13 +19,12 @@ class FutureTomwerObject:
     """Container for an existing TomwerScanBase with some future object
     (like slice reconstruction on slurm...)
 
-    :param TomwerScanBase scan: scan at the origin of the FutureTomwerScan
-    :param tuple futures: tuple of Future
+    :param scan: scan at the origin of the FutureTomwerScan
+    :param futures: tuple of Future
     :param start_time: start_time of the FutureTomwerScan. If not provided
                        this will be set to the date of creation of the object.
-    :type start_time: Optional[datetime.time]
-    :param int process_requester_id: process of the id requesting future
-                                     processing. This is usefull to keep a trace on
+    :param process_requester_id: process of the id requesting future
+                                     processing. This is useful to keep a trace on
                                      the source of the computation. To display
                                      supervisor 'request' for example.
     """
@@ -58,9 +32,9 @@ class FutureTomwerObject:
     def __init__(
         self,
         tomo_obj: TomwerObject,
-        futures: Optional[Union[tuple, list]],
-        start_time: Optional[datetime.time] = None,
-        process_requester_id: Optional[int] = None,
+        futures: tuple | list | None,
+        start_time: datetime.time | None = None,
+        process_requester_id: int | None = None,
     ):
         if not isinstance(tomo_obj, TomwerObject):
             raise TypeError(
@@ -83,11 +57,11 @@ class FutureTomwerObject:
             self._futures = list(futures)
 
     @property
-    def job_id(self) -> Optional[int]:
+    def job_id(self) -> int | None:
         return self._job_id
 
     @property
-    def status(self) -> Optional[str]:
+    def status(self) -> str | None:
         all_status = [
             get_job_status(fut.job_id) if hasattr(fut, "job_id") else "unknown"
             for fut in self._futures
@@ -120,7 +94,7 @@ class FutureTomwerObject:
         )
 
     @property
-    def start_time(self) -> Optional[datetime.time]:
+    def start_time(self) -> datetime.time | None:
         return self._start_time
 
     @property
@@ -129,7 +103,7 @@ class FutureTomwerObject:
         return self._tomo_obj
 
     @property
-    def futures(self) -> Optional[tuple]:
+    def futures(self) -> tuple | None:
         if self._futures is None:
             return None
         else:
@@ -143,7 +117,7 @@ class FutureTomwerObject:
         self._futures.extend(futures)
 
     @property
-    def process_requester_id(self) -> Optional[int]:
+    def process_requester_id(self) -> int | None:
         return self._process_requester_id
 
     def results(self) -> TomwerScanBase:
@@ -164,7 +138,7 @@ class FutureTomwerObject:
             done = done and future.done()
         return done
 
-    def exceptions(self) -> Optional[dict]:
+    def exceptions(self) -> dict | None:
         """
         Return exception with future as key and exception as value
         """

tomwer/core/log/__init__.py

@@ -0,0 +1,2 @@
+"""contains some log utils (used to notify processing advancement)
+"""

tomwer/core/log/processlog.py

@@ -1,36 +1,8 @@
 # coding: utf-8
-# ##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################
 """
 Simple logs levels definition relative to process status
 """
 
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "02/10/2020"
-
 import logging
 
 PROCESS_STARTED_NAME = "PROCESS_STARTED"