tomwer 1.1.0rc7__py3-none-any.whl → 1.2.0a0__py3-none-any.whl

tomwer/synctools/stacks/reconstruction/nabu.py

@@ -27,18 +27,21 @@ __license__ = "MIT"
 __date__ = "28/08/2020"
 
 
+import gc
+import logging
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
 from silx.gui import qt
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.scan.edfscan import EDFTomoScan
+
 from tomwer.core.process.reconstruction.nabu import nabuslices, nabuvolume
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils import isLowOnMemory
 from tomwer.io.utils import format_stderr_stdout
+
 from ..processingstack import FIFO, ProcessingThread
-from processview.core.superviseprocess import SuperviseProcess
-from processview.core.manager import ProcessManager, DatasetState
-import gc
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -53,7 +56,7 @@ class NabuSliceProcessStack(FIFO, qt.QObject):
         self._dry_run = False
 
     def _process(self, data, configuration, callback=None):
-        _logger.info("Nabu slice stack is processing {}".format(str(data)))
+        _logger.info(f"Nabu slice stack is processing {data}")
         ProcessManager().notify_dataset_state(
             dataset=data,
             process=self,
@@ -66,7 +69,7 @@ class NabuSliceProcessStack(FIFO, qt.QObject):
 
         if isOnLbsram(data) and isLowOnMemory(get_lbsram_path()) is True:
             # if computer is running into low memory on lbsram skip it
-            mess = "low memory, skip nabu reconstruction for", data.path
+            mess = f"low memory, skip nabu reconstruction for {data.path}"
             _logger.processSkipped(mess)
             ProcessManager().notify_dataset_state(
                 dataset=data,
@@ -128,7 +131,7 @@ class _SliceProcessingThread(ProcessingThread, SuperviseProcess):
 
     def run(self):
         self.sigComputationStarted.emit()
-        mess = "Start nabu slice(s) reconstruction of {}".format(str(self._scan))
+        mess = f"Start nabu slice(s) reconstruction of {self._scan}"
         _logger.processStarted(mess)
         ProcessManager().notify_dataset_state(
             dataset=self._scan,
@@ -187,12 +190,12 @@ class _SliceProcessingThread(ProcessingThread, SuperviseProcess):
 
             # TODO: check output files with the tomoscan validator ?
             if not succeed:
-                mess = "Slices computation for {} failed.".format(str(self._scan))
+                mess = f"Slices computation for {self._scan} failed."
                 state = DatasetState.FAILED
                 _logger.processFailed(mess)
             else:
                 state = DatasetState.SUCCEED
-                mess = "Slices computed for {}.".format(str(self._scan))
+                mess = f"Slices computed for {self._scan}."
                 _logger.processSucceed(mess)
             elmts = [
                 format_stderr_stdout(stderr=stderr, stdout=stdout)
@@ -216,7 +219,7 @@ class _VolumeProcessingThread(_SliceProcessingThread):
 
     def run(self):
         self.sigComputationStarted.emit()
-        mess = "Start nabu volume reconstruction of {}".format(str(self._scan))
+        mess = f"Start nabu volume reconstruction of {self._scan}"
         _logger.processStarted(mess)
         ProcessManager().notify_dataset_state(
             dataset=self._scan,
@@ -241,9 +244,7 @@ class _VolumeProcessingThread(_SliceProcessingThread):
             )
         except Exception as e:
             self._future_tomo_obj = None
-            mess = "Fail to compute volume for {}. Reason is {}".format(
-                str(self._scan), e
-            )
+            mess = f"Fail to compute volume for {e}. Reason is {e}"
             _logger.processFailed(mess)
             ProcessManager().notify_dataset_state(
                 dataset=self._scan,
@@ -276,11 +277,11 @@ class _VolumeProcessingThread(_SliceProcessingThread):
             ]
 
             if not succeed:
-                mess = "Volume computed for {} failed.".format(str(self._scan))
+                mess = f"Volume computed for {self._scan} failed."
                 _logger.processFailed(mess)
                 state = DatasetState.FAILED
             else:
-                mess = "Volume computed for {}.".format(str(self._scan))
+                mess = f"Volume computed for {self._scan}."
                 _logger.processSucceed(mess)
                 state = DatasetState.SUCCEED
 

tomwer/synctools/stacks/reconstruction/normalization.py

@@ -27,19 +27,19 @@ __license__ = "MIT"
 __date__ = "19/07/2021"
 
 
-from tomwer.core.process.reconstruction.normalization import (
-    SinoNormalizationTask,
-)
-from processview.core.manager import ProcessManager
+import functools
+import logging
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+from silx.gui import qt
+
+from tomwer.core.process.reconstruction.normalization import SinoNormalizationTask
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils import isLowOnMemory
-from processview.core.manager import DatasetState
+
 from ..processingstack import FIFO, ProcessingThread
-from processview.core.superviseprocess import SuperviseProcess
-from silx.gui import qt
-import functools
-import logging
 
 _logger = logging.getLogger(__name__)
 
@@ -58,7 +58,7 @@ class INormalizationProcessStack(FIFO, qt.QObject):
             process=self,
             state=DatasetState.ON_GOING,
         )
-        _logger.processStarted("start intensity normalization {}".format(str(data)))
+        _logger.processStarted(f"start intensity normalization {data}")
         assert isinstance(data, TomwerScanBase)
         if isOnLbsram(data) and isLowOnMemory(get_lbsram_path()) is True:
             # if computer is running into low memory on lbsram skip it
@@ -121,14 +121,10 @@ class _ProcessingThread(ProcessingThread, SuperviseProcess):
             norm_process.run()
         except Exception as e:
             _logger.error(str(e))
-            mess = "Intensity normalization computation for {} failed.".format(
-                str(self._scan)
-            )
+            mess = f"Intensity normalization computation for {self._scan} failed."
             state = DatasetState.FAILED
         else:
-            mess = "Intensity normalization computation for {} succeed.".format(
-                str(self._scan)
-            )
+            mess = f"Intensity normalization computation for {self._scan} succeed."
             state = DatasetState.WAIT_USER_VALIDATION
 
         ProcessManager().notify_dataset_state(

tomwer/synctools/stacks/reconstruction/saaxis.py

@@ -27,20 +27,22 @@ __license__ = "MIT"
 __date__ = "03/05/2019"
 
 
+import functools
+import logging
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+from silx.gui import qt
+
 from tomwer.core.process.reconstruction.saaxis import SAAxisProcess
-from processview.core.manager import ProcessManager
-from tomwer.synctools.saaxis import QSAAxisParams
-from tomwer.synctools.axis import QAxisRP
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils import isLowOnMemory
-from processview.core.manager import DatasetState
-from ..processingstack import FIFO, ProcessingThread
-from processview.core.superviseprocess import SuperviseProcess
 from tomwer.io.utils import format_stderr_stdout
-from silx.gui import qt
-import logging
-import functools
+from tomwer.synctools.axis import QAxisRP
+from tomwer.synctools.saaxis import QSAAxisParams
+
+from ..processingstack import FIFO, ProcessingThread
 
 _logger = logging.getLogger(__name__)
 
@@ -68,7 +70,7 @@ class SAAxisProcessStack(FIFO, qt.QObject):
             process=self,
             state=DatasetState.ON_GOING,
         )
-        _logger.processStarted("start saaxis {}" "".format(str(data)))
+        _logger.processStarted(f"start saaxis {data}")
         assert isinstance(data, TomwerScanBase)
         if data.axis_params is None:
             data.axis_params = QAxisRP()
@@ -79,7 +81,7 @@ class SAAxisProcessStack(FIFO, qt.QObject):
         saaxis_params.frame_width = data.dim_1
         if isOnLbsram(data) and isLowOnMemory(get_lbsram_path()) is True:
             # if computer is running into low memory on lbsram skip it
-            mess = "low memory, skip saaxis calculation", data.path
+            mess = f"low memory, skip saaxis calculation {data.path}"
             ProcessManager().notify_dataset_state(
                 dataset=data, process=self._process_id, state=DatasetState.SKIPPED
             )

tomwer/synctools/stacks/reconstruction/sadeltabeta.py

@@ -27,22 +27,24 @@ __license__ = "MIT"
 __date__ = "08/06/2021"
 
 
-from processview.core.manager import ProcessManager
-from tomwer.synctools.sadeltabeta import QSADeltaBetaParams
-from tomwer.synctools.axis import QAxisRP
-from tomwer.core.scan.scanbase import TomwerScanBase
+import functools
+import logging
+
+from processview.core.manager import DatasetState, ProcessManager
+from processview.core.superviseprocess import SuperviseProcess
+from silx.gui import qt
+
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
     SADeltaBetaProcess,
 )
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils import isLowOnMemory
-from processview.core.manager import DatasetState
-from ..processingstack import FIFO, ProcessingThread
-from processview.core.superviseprocess import SuperviseProcess
 from tomwer.io.utils import format_stderr_stdout
-from silx.gui import qt
-import logging
-import functools
+from tomwer.synctools.axis import QAxisRP
+from tomwer.synctools.sadeltabeta import QSADeltaBetaParams
+
+from ..processingstack import FIFO, ProcessingThread
 
 _logger = logging.getLogger(__name__)
 
@@ -70,7 +72,7 @@ class SADeltaBetaProcessStack(FIFO, qt.QObject):
             process=self,
             state=DatasetState.ON_GOING,
         )
-        _logger.processStarted("start sa-delta-beta {}" "".format(str(data)))
+        _logger.processStarted(f"start sa-delta-beta {data}")
         assert isinstance(data, TomwerScanBase)
         if data.axis_params is None:
             data.axis_params = QAxisRP()
@@ -80,7 +82,7 @@ class SADeltaBetaProcessStack(FIFO, qt.QObject):
         sa_delta_beta_params = QSADeltaBetaParams.from_dict(configuration)
         if isOnLbsram(data) and isLowOnMemory(get_lbsram_path()) is True:
             # if computer is running into low memory on lbsram skip it
-            mess = "low memory, skip sa-delta-beta-axis calculation", data.path
+            mess = f"low memory, skip sa-delta-beta-axis calculation {data.path}"
             ProcessManager().notify_dataset_state(
                 dataset=data, process=self._process_id, state=DatasetState.SKIPPED
             )
@@ -176,10 +178,10 @@ class _ProcessingThread(ProcessingThread, SuperviseProcess):
                 sa_delta_beta.run()
             except Exception as e:
                 _logger.error(str(e))
-                mess = "SADeltaBeta computation for {} failed.".format(str(self._scan))
+                mess = f"SADeltaBeta computation for {self._scan} failed."
                 state = DatasetState.FAILED
             else:
-                mess = "SADeltaBeta computation for {} succeed.".format(str(self._scan))
+                mess = f"SADeltaBeta computation for {self._scan} succeed."
                 state = DatasetState.WAIT_USER_VALIDATION
                 self.db_value = self._scan.sa_delta_beta_params.autofocus
 

tomwer/synctools/test/test_darkRefs.py

@@ -31,14 +31,15 @@ __date__ = "11/12/2017"
 import os
 import shutil
 import tempfile
+
 import fabio
 import numpy
 from silx.gui.utils.testutils import TestCaseQt
-from tomwer.core.utils.scanutils import MockEDF
+
 from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefs
-from tomwer.core.process.reconstruction.darkref.params import DKRFRP
-from tomwer.core.process.reconstruction.darkref.params import ReduceMethod
+from tomwer.core.process.reconstruction.darkref.params import DKRFRP, ReduceMethod
 from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import MockEDF
 from tomwer.tests.utils import UtilsTest
 
 

tomwer/synctools/test/test_foldertransfer.py

@@ -28,22 +28,24 @@ __license__ = "MIT"
 __date__ = "24/01/2017"
 
 
-from tomwer.synctools.datatransfert import ScanTransfer
+import logging
+import os
+import shutil
+import tempfile
+import unittest
+from glob import glob
+
+import pytest
+from nxtomomill.converter import from_h5_to_nx
+from nxtomomill.io.config.hdf5config import TomoHDF5Config
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils import rebaseParFile
 from tomwer.core.utils.scanutils import MockEDF
+from tomwer.synctools.datatransfert import ScanTransfer
 from tomwer.tests.utils import UtilsTest
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from nxtomomill.converter import from_h5_to_nx
-from nxtomomill.io.config.hdf5config import TomoHDF5Config
-from silx.gui.utils.testutils import TestCaseQt
-from glob import glob
-import unittest
-import os
-import tempfile
-import shutil
-import logging
-import pytest
 
 try:
     from tomwer.synctools.rsyncmanager import RSyncManager

tomwer/synctools/test/test_scanstages.py

@@ -28,18 +28,19 @@ __license__ = "MIT"
 __date__ = "30/09/2019"
 
 
-import unittest
-import tempfile
+import glob
 import os
 import shutil
-import glob
+import tempfile
+import unittest
 from collections import namedtuple
-from tomwer.tests.utils import UtilsTest
-from tomwer.synctools.utils.scanstages import ScanStages
-from tomwer.core.scan.scanfactory import ScanFactory
-from tomwer.tests.utils import skip_gui_test
+
 import pytest
 
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.synctools.utils.scanstages import ScanStages
+from tomwer.tests.utils import UtilsTest, skip_gui_test
+
 if skip_gui_test() is False:
     from tomwer.synctools.rsyncmanager import RSyncManager
 

tomwer/synctools/utils/scanstages.py

@@ -30,14 +30,16 @@ __license__ = "MIT"
 __date__ = "09/01/2020"
 
 
-import shutil
 import glob
-from tomwer.core.scan.scanbase import TomwerScanBase
+import os
+import shutil
+
+from silx.io.url import DataUrl
+from silx.utils.enum import Enum as _Enum
+
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from silx.utils.enum import Enum as _Enum
-from silx.io.url import DataUrl
-import os
+from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.synctools.rsyncmanager import RSyncManager
 
 

tomwer/tests/conftest.py

@@ -1,8 +1,8 @@
-import pytest
-from ewoksorange.bindings.qtapp import qtapp_context
-from ewoksorange.bindings.qtapp import get_all_qtwidgets
-import logging
 import gc
+import logging
+
+import pytest
+from ewoksorange.bindings.qtapp import get_all_qtwidgets, qtapp_context
 
 _logger = logging.getLogger(__name__)
 

tomwer/tests/test_scripts.py

@@ -33,10 +33,11 @@ __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
 __date__ = "21/02/2018"
 
 
-import sys
-import unittest
 import logging
 import subprocess
+import sys
+import unittest
+
 from tomwer.tests.utils.utilstest import UtilsTest
 
 _logger = logging.getLogger(__name__)

tomwer/tests/utils/__init__.py

@@ -33,11 +33,12 @@ __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
 __date__ = "07/02/2017"
 
+import fileinput
+import logging
 import os
 import shutil
-import fileinput
+
 from tomwer.core.utils import DownloadDataset, url_base
-import logging
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
@@ -186,8 +187,8 @@ class UtilsTest(object):
         if "TOMWER_ADDITIONAL_TESTS_DIR" not in os.environ:
             return False
         else:
-            dir = os.path.join(os.environ["TOMWER_ADDITIONAL_TESTS_DIR"], dataset)
-        return os.path.isdir(dir)
+            dir_ = os.path.join(os.environ["TOMWER_ADDITIONAL_TESTS_DIR"], dataset)
+        return os.path.isdir(dir_)
 
     @classmethod
     def getInternalTestDir(cls, dataset):

tomwer/tests/utils/utilstest.py

@@ -30,17 +30,16 @@ __license__ = "MIT"
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
 __date__ = "24/01/2018"
 
+import getpass
+import logging
 import os
+import shutil
 import sys
+import tempfile
 import threading
 import unittest
-import logging
-import shutil
-import tempfile
-import getpass
-
-
 from argparse import ArgumentParser
+
 from silx.resources import ExternalResources
 
 PACKAGE = "pyFAI"

tomwer/third_party/nabu/preproc/phase.py

@@ -1,12 +1,14 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import numpy as np
-from math import pi
 from bisect import bisect
-from ..utils import generate_powers
+from math import pi
+
+import numpy as np
 from silx.utils.enum import Enum as _Enum
 
+from ..utils import generate_powers
+
 
 def lmicron_to_db(Lmicron, energy, distance):
     """
@@ -359,9 +361,9 @@ class PaganinPhaseRetrieval(object):
         padding_method = padding_method or self.padding
         padding_method = PaddingMode.from_value(padding_method)
         if padding_method not in self.padding_methods:
+            valid_padding_modes = list(self.padding_methods.keys())
             raise ValueError(
-                "Unknown padding method %s. Available are: %s"
-                % (padding_method, str(list(self.padding_methods.keys())))
+                f"Unknown padding method {padding_method}. Available are: {valid_padding_modes}"
             )
         pad_func = self.padding_methods[padding_method]
         pad_func(data)

tomwer/third_party/nabu/utils.py

@@ -1,7 +1,8 @@
 import os
-import numpy as np
-from time import time
 from itertools import product
+from time import time
+
+import numpy as np
 
 _warnings = {}
 

tomwer/utils.py

@@ -22,6 +22,9 @@
 # THE SOFTWARE.
 #
 # ###########################################################################*/
+"""
+some project general utils functions
+"""
 
 __authors__ = ["H. Payno", "T. Vincent"]
 __license__ = "MIT"
@@ -30,19 +33,16 @@ __date__ = "04/01/2018"
 
 import argparse
 import functools
+import importlib
+import logging
+import sys
+
 from silx.utils.launcher import Launcher as _Launcher
 from silx.utils.launcher import LauncherCommand as _LauncherCommand
-import sys
-import logging
-import importlib
 
 _logger = logging.getLogger(__file__)
 
 
-def addHTMLLine(txt):
-    return "<li>" + txt + "</li>"
-
-
 def _docstring(dest, origin):
     """Implementation of docstring decorator.
 
@@ -202,12 +202,12 @@ class Launcher(_Launcher):
             return 0
 
         if command_name not in self._commands:
-            print("Unknown command: %s", command_name)
+            print(f"Unknown command: {command_name}")
             self.print_help()
             return -1
 
         command = self._commands[command_name]
-        prog = "%s %s" % (self.prog, command.name)
+        prog = f"{self.prog} {command.name}"
         return command.execute([prog, "--help"])
 
     def execute(self, argv=None):
@@ -228,7 +228,7 @@ class Launcher(_Launcher):
         command_name = argv[1]
 
         if command_name == "--version":
-            print("%s version %s" % (self.prog, str(self.version)))
+            print(f"{self.prog} version {str(self.version)}")
             return 0
 
         if command_name in ["--help", "-h"]:
@@ -239,10 +239,10 @@ class Launcher(_Launcher):
             else:
                 command_name = argv[2]
                 command_argv = argv[2:] + ["--help"]
-                command_argv[0] = "%s %s" % (self.prog, command_argv[0])
+                command_argv[0] = f"{self.prog} {command_argv[0]}"
         else:
             command_argv = argv[1:]
-            command_argv[0] = "%s %s" % (self.prog, command_argv[0])
+            command_argv[0] = f"{self.prog} {command_argv[0]}"
 
         if command_name not in self._commands:
             print("Unknown command: %s" % command_name)

tomwer/version.py

@@ -76,10 +76,10 @@ RELEASE_LEVEL_VALUE = {
 }
 
 MAJOR = 1
-MINOR = 1
+MINOR = 2
 MICRO = 0
-RELEV = "rc"  # <16
-SERIAL = 7  # <16
+RELEV = "alpha"  # <16
+SERIAL = 0  # <16
 
 date = __date__
 

tomwer/web/__init__.py

@@ -0,0 +1,30 @@
+# 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.
+#
+#############################################################################*/
+"""Module containing process relative to the web (like classes used to link
+with graylog)
+"""
+
+__authors__ = ["H.Payno"]
+__license__ = "MIT"
+__date__ = "15/05/2017"

tomwer/web/client.py

@@ -0,0 +1,43 @@
+# 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.
+#
+#############################################################################*/
+"""module defining functions and class to communicate a status to the
+orange-server.
+The orange-server is used to display the advancement of the workflow.
+"""
+
+__authors__ = ["H.Payno"]
+__license__ = "MIT"
+__date__ = "28/04/2017"
+
+
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+class OWClient(object):
+    """Orange widget Client can emit information about his advancement"""
+
+    WORKFLOW_INFO = "workflow"  # general information about a workflow
+    SCAN_INFO = "scan"  # information focus on a scan