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

tomwer/app/canvas_launcher/mainwindow.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import argparse
 import logging
 import os
@@ -5,10 +7,8 @@ import shutil
 import signal
 import sys
 import silx
-from typing import List
 from contextlib import closing
 from logging.handlers import RotatingFileHandler
-from urllib.request import urlopen
 from xml.sax.saxutils import escape
 
 import pyqtgraph
@@ -28,14 +28,23 @@ from processview.gui.processmanager import ProcessManagerWindow
 from silx.gui import qt
 
 import tomwer.version
-from tomwer.core.log.logger import TomwerLogger
 from orangecanvas.preview import previewdialog, previewmodel
 from orangecanvas.application import examples as orange_examples
-import ewoks
+import ewokscore
+import ewoksorange
 import tomoscan.version
 
 from .config import TomwerConfig, TomwerSplashScreen
 
+from tomwer.core.log.processlog import (
+    PROCESS_ENDED_NAME,
+    PROCESS_FAILED_NAME,
+    PROCESS_INFORM_NAME,
+    PROCESS_SKIPPED_NAME,
+    PROCESS_STARTED_NAME,
+    PROCESS_SUCCEED_NAME,
+)
+
 try:
     import nabu
 except ImportError:
@@ -71,9 +80,38 @@ LOG_FILE_NAME = "tomwer.log"
 LOG_FOLDER = "/var/log/tomwer"
 
 
+# These are the sequences need to get colored ouput
+_RESET_SEQ = "\033[0m"
+
+_BLACK = "\033[30m"
+_RED = "\033[31m"
+_GREEN = "\033[32m"
+_YELLOW = "\033[33m"
+_BLUE = "\033[34m"
+_MAGENTA = "\033[35m"
+
+
+LOG_COLORS = {
+    "WARNING": _MAGENTA,
+    "INFO": _BLACK,
+    "DEBUG": _BLUE,
+    "CRITICAL": _YELLOW,
+    "ERROR": _RED,
+    PROCESS_SKIPPED_NAME: _MAGENTA,
+    PROCESS_ENDED_NAME: _BLACK,
+    PROCESS_INFORM_NAME: _BLACK,
+    PROCESS_STARTED_NAME: _BLACK,
+    PROCESS_FAILED_NAME: _RED,
+    PROCESS_SUCCEED_NAME: _GREEN,
+}
+
+
 class MainWindow(_MainWindow):
     HELPDESK_URL = "https://requests.esrf.fr/plugins/servlet/desk/portal/41"
 
+    FORCE_OBJECT_SUPERVISOR_DISPLAY = True
+    """If true will always display the processed supervisor at start up. Restore state will be ignored."""
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.process_supervisor_dock = DockWidget(
@@ -90,6 +128,15 @@ class MainWindow(_MainWindow):
         )
         self.addDockWidget(qt.Qt.BottomDockWidgetArea, self.process_supervisor_dock)
 
+    def restoreState(self, state, version=0):
+        # for now we always want to display the process supervisor
+        restored = super().restoreState(state=state, version=version)
+        if self.FORCE_OBJECT_SUPERVISOR_DISPLAY:
+            self.show_processes_manager_action.setChecked(True)
+            self.process_supervisor_dock.setVisible(True)
+
+        return restored
+
     def setup_actions(self):
         super().setup_actions()
         # create the action to connect with it
@@ -146,6 +193,14 @@ class MainWindow(_MainWindow):
             triggered=self.open_python_script_example,
             menuRole=qt.QAction.AboutRole,
         )
+        self.python_script_example_action = qt.QAction(
+            self.tr("ID16b examples"),
+            self,
+            objectName="id16b-example",
+            toolTip=self.tr("ID16b use case."),
+            triggered=self.open_id16b_example,
+            menuRole=qt.QAction.AboutRole,
+        )
         # Predefined workflows menu.
         self.predefined_workflows_menu = qt.QMenu(
             self.tr("&Examples"),
@@ -243,6 +298,11 @@ class MainWindow(_MainWindow):
             orange_examples.workflows(), filter_names=("_script",)
         )
 
+    def open_id16b_example(self):
+        return self.__open_examples(
+            orange_examples.workflows(), filter_names=("ID16b",)
+        )
+
     def open_cor_search_example(self):
         return self.__open_examples(
             orange_examples.workflows(), filter_names=("find_cor", "cor_search")
@@ -293,7 +353,7 @@ class _OMain(ocMain):
         )
         return parser
 
-    def parse_arguments(self, argv: List[str]):
+    def parse_arguments(self, argv: list[str]):
         super().parse_arguments(argv)
         # define silx plot backend. For now the si;pler is to
         # define an environment variable.
@@ -310,7 +370,40 @@ class _OMain(ocMain):
             silx.config.DEFAULT_PLOT_BACKEND = "matplotlib"
 
     def setup_logging(self):
-        super().setup_logging()
+        level = self.options.log_level
+        logformat = "%(asctime)s:%(levelname)s:%(name)s: %(message)s"
+
+        # File handler should always be at least INFO level so we need
+        # the application root level to be at least at INFO.
+        root_level = min(level, logging.INFO)
+        rootlogger = logging.getLogger()
+        rootlogger.setLevel(root_level)
+
+        # Standard output stream handler at the requested level
+        if sys.platform in ("linux", "linux2", "darwin"):
+            stream_hander = make_linux_stream_colored_handler(
+                level, fileobj=self.__stderr__
+            )
+        else:
+            stream_hander = make_stream_handler(
+                level, fileobj=self.__stderr__, fmt=logformat
+            )
+        rootlogger.addHandler(stream_hander)
+        # Setup log capture for MainWindow/Log
+        log_stream = TextStream(objectName="-log-stream")
+        self.output.connectStream(log_stream)
+        self.stack.push(closing(log_stream))  # close on exit
+        log_handler = make_stream_handler(level, fileobj=log_stream, fmt=logformat)
+        rootlogger.addHandler(log_handler)
+
+        # Also log to file
+        file_handler = make_file_handler(
+            root_level,
+            os.path.join(config.log_dir(), "canvas.log"),
+            mode="w",
+        )
+        rootlogger.addHandler(file_handler)
+
         make_sql_logger(self.options.log_level)
 
     def setup_application(self):
@@ -381,11 +474,12 @@ ABOUT_TEMPLATE = """\
 <h4>{name}</h4>
 <p>tomwer version: {tomwer_version}</p>
 <p>nabu version: {nabu_version}</p>
-<p>nxtomomill version: {nxtomomill_version}</p>
 <p>nxtomo version: {nxtomo_version}</p>
+<p>nxtomomill version: {nxtomomill_version}</p>
 <p>tomoscan version: {tomoscan_version}</p>
+<p>ewokscore version: {ewokscore_version}</p>
+<p>ewoksorange version: {ewoksorange_version}</p>
 <p>sluurp version: {sluurp_version}</p>
-<p>ewoks version: {ewoks_version}</p>
 """
 
 
@@ -416,8 +510,13 @@ class AboutDialog(qt.QDialog):
             sluurp_version=escape(
                 sluurp.__version__ if has_sluurp else "not installed"
             ),
-            ewoks_version=escape(
-                ewoks.__version__ if hasattr(ewoks, "__version__") else "???"
+            ewokscore_version=escape(
+                ewokscore.__version__ if hasattr(ewokscore, "__version__") else "???"
+            ),
+            ewoksorange_version=escape(
+                ewoksorange.__version__
+                if hasattr(ewoksorange, "__version__")
+                else "???"
             ),
         )
         text_label = qt.QLabel(text)
@@ -446,45 +545,45 @@ class OMain(_OMain):
 
     def setup_logging(self):
         super().setup_logging()
-        rootlogger = logging.getLogger()
-        rootlogger = TomwerLogger(rootlogger)
-        logging.setLoggerClass(TomwerLogger)
+        # rootlogger = logging.getLogger()
+        # rootlogger = TomwerLogger(rootlogger)
+        # logging.setLoggerClass(TomwerLogger)
 
     def setup_sys_redirections(self):
-        self._tomwLogger = TomwerLogger("tomwer")
-        try:
-            self.output = doc = TerminalTextDocument()
+        self.output = doc = TerminalTextDocument()
 
-            stdout = TextStream(objectName="-stdout")
-            stderr = TextStream(objectName="-stderr")
-            doc.connectStream(stdout)
-            doc.connectStream(stderr, color=qt.Qt.red)
+        stdout = TextStream(objectName="-stdout")
+        stderr = TextStream(objectName="-stderr")
+        doc.connectStream(stdout)
+        doc.connectStream(stderr, color=qt.Qt.red)
 
-            if sys.stdout is not None:
-                stdout.stream.connect(sys.stdout.write, qt.Qt.DirectConnection)
+        if sys.stdout is not None:
+            stdout.stream.connect(sys.stdout.write, qt.Qt.DirectConnection)
 
-            self.__stdout__ = sys.stdout
-            sys.stdout = stdout
+        self.__stdout__ = sys.stdout
+        sys.stdout = stdout
 
-            if sys.stderr is not None:
-                stderr.stream.connect(sys.stderr.write, qt.Qt.DirectConnection)
+        if sys.stderr is not None:
+            stderr.stream.connect(sys.stderr.write, qt.Qt.DirectConnection)
 
-            self.__stderr__ = sys.stderr
-            sys.stderr = stderr
-            self.__excepthook__ = sys.excepthook
-            sys.excepthook = ExceptHook(stream=stderr)
+        self.__stderr__ = sys.stderr
+        sys.stderr = stderr
+        self.__excepthook__ = sys.excepthook
+        sys.excepthook = ExceptHook(stream=stderr)
 
-            self.stack.push(closing(stdout))
-            self.stack.push(closing(stderr))
-        except Exception:
-            super().setup_sys_redirections()
+        self.stack.push(closing(stdout))
+        self.stack.push(closing(stderr))
 
     def argument_parser(self) -> argparse.ArgumentParser:
         parser = super().argument_parser()
         for action in parser._actions:
+            # avoid clearing settings because this make people confused
             if action.dest == "clear_widget_settings":
                 parser._remove_action(action)
                 break
+            # by default log are only displaying errors. But we want to get warning as well (for deprecation for example).
+            if action.dest == "log_level":
+                action.default = logging.WARNING
 
         parser.add_argument(
             "--no-color-stdout-logs",
@@ -534,38 +633,45 @@ def dealWithLogFile():
         )
 
 
-def check_is_latest_release() -> bool:
-    """Check if the current version is the latest release."""
-    url = "https://gitlab.esrf.fr/tomotools/tomwer/-/raw/master/tomwer/version.py"
-    current_version = tomwer.version.version
-    try:
-        version_file_html = urlopen(url, data=None, timeout=10)
-    except Exception as e:
-        _logger.warning(f"Fail to load version of the latest release. Reason is {e}")
-        return True
-    else:
-        latest_release_version = None
-        for line in version_file_html.readlines():
-            t_line = line.decode("utf-8")
-            t_line = t_line.replace(" ", "")
-            if t_line.startswith("latest_release_version_info="):
-                latest_release_version = t_line.replace(
-                    "latest_release_version_info=", ""
-                )
-                break
-        if latest_release_version is None:
-            _logger.warning("Unable to find the version of the latest " "release.")
-
-        elif current_version < latest_release_version:
-            msg = qt.QMessageBox()
-            msg.setIcon(qt.QMessageBox.Question)
-            types = qt.QMessageBox.Ok | qt.QMessageBox.Cancel
-            message = (
-                "The version you want to use ({}) is not the latest "
-                "version ({}). Do you want to continue ?"
-            )
-            msg.setStandardButtons(types)
-            msg.setWindowTitle("No the latest version")
-            msg.setText(message)
-            return msg.exec_() == qt.QMessageBox.Ok
-        return True
+class _ColoredFormatter(logging.Formatter):
+    """Dedicated colors to highlight level name by coloring logs (only for linux terminals)"""
+
+    @staticmethod
+    def color_formatting(message: str, levelname: str, ascii_time):
+        """colors message using ascii"""
+        return (
+            f"{ascii_time} {LOG_COLORS[levelname]}[{levelname}]{_RESET_SEQ} {message}"
+        )
+
+    def format(self, record):
+        record.asctime = self.formatTime(record, "%Y-%m-%d %H:%M:%S")
+        record.message = record.getMessage()
+        return self.color_formatting(
+            message=record.message,
+            levelname=record.levelname,
+            ascii_time=record.asctime,
+        )
+
+
+def make_linux_stream_colored_handler(level, fileobj=None):
+    handler = logging.StreamHandler(fileobj)
+    handler.setLevel(level)
+    formatter = _ColoredFormatter()
+    handler.setFormatter(formatter)
+    return handler
+
+
+def make_stream_handler(level, fileobj=None, fmt=None):
+    handler = logging.StreamHandler(fileobj)
+    handler.setLevel(level)
+    if fmt:
+        handler.setFormatter(logging.Formatter(fmt))
+    return handler
+
+
+def make_file_handler(level, filename, mode="w", fmt=None):
+    handler = logging.FileHandler(filename, mode=mode, encoding="utf-8")
+    handler.setLevel(level)
+    if fmt:
+        handler.setFormatter(logging.Formatter(fmt))
+    return handler

tomwer/app/canvas_launcher/splash.py

@@ -7,9 +7,8 @@ def splash_screen():
     """
 
     :return: splash screen for orange-canvas
-    :rtype: tuple(QPixmap, QRect),
 
-    note: QRect is used by orange to define a mask to display the message.
+    :note: QRect is used by orange to define a mask to display the message.
           In our case we overwrite the QSplashScreen so we don't need this.
     """
     pixmap = icons.getQPixmap("tomwer")
@@ -20,7 +19,6 @@ def getIcon():
     """
 
     :return: application icon
-    :rtype: QIcon
     """
     pixmap = icons.getQPixmap("tomwer")
     return qt.QIcon(pixmap)

tomwer/app/canvas_launcher/utils.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import tomoscan.version
+
+import ewokscore
+import ewoksorange
+import tomwer.version
+import sluurp
+
+try:
+    import nxtomomill.version
+except ImportError:
+    has_nxtomomill = False
+else:
+    has_nxtomomill = True
+try:
+    import nabu
+except ImportError:
+    has_nabu = False
+else:
+    has_nabu = True
+try:
+    import nxtomo.version
+except ImportError:
+    has_nxtomo = False
+else:
+    has_nxtomo = True
+
+
+def get_tomotools_stack_versions() -> dict[str, str]:
+    """Return the version of the main libraries used by tomwer"""
+    stack = {
+        "tomwer": tomwer.version.version,
+    }
+
+    if has_nabu:
+        stack["nabu"] = nabu.version
+    if has_nxtomo:
+        stack["nxtomo"] = nxtomo.version.version
+    if has_nxtomomill:
+        stack["nxtomomill"] = nxtomomill.version.version
+    stack["tomoscan"] = tomoscan.version.version
+    stack["ewokscore"] = ewokscore.__version__
+    stack["ewoksorange"] = ewoksorange.__version__
+    stack["sluurp"] = sluurp.__version__
+
+    return stack

tomwer/app/canvas_launcher/widgetsscheme.py

@@ -52,13 +52,10 @@ class WidgetsScheme(Scheme):
     def show_report_view(self):
         return
 
-    def has_report(self):
+    def has_report(self) -> bool:
         """
         Does this workflow have an associated report
 
-        Returns
-        -------
-        has_report: bool
         """
         return self.__report_view is not None
 
@@ -66,9 +63,7 @@ class WidgetsScheme(Scheme):
         """
         Return a OWReport instance used by the workflow.
 
-        Returns
-        -------
-        report : OWReport
+        :return: report
         """
         return None
 
@@ -76,9 +71,7 @@ class WidgetsScheme(Scheme):
         """
         Set the designated OWReport view for this workflow.
 
-        Parameters
-        ----------
-        view :
+        :param view:
         """
         self.__report_view = None
 

tomwer/app/diffframe.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+"""Application to display the difference between two frames.
+"""
 
 import argparse
 import logging

tomwer/app/imagekeyeditor.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
+"""Application to edit (key by key) the 'imagekey' value of a NXtomo ('imagekey' defines if a frame is a 'dark', 'flat' or a 'projection')
+"""
 import argparse
 import logging
 import signal

tomwer/app/imagekeyupgrader.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+"""Application to edit (group by group) the 'imagekey' value of a NXtomo ('imagekey' defines if a frame is a 'dark', 'flat' or a 'projection')
+"""
 
 import argparse
 import logging

tomwer/app/multicor.py

@@ -1,12 +1,15 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+"""Application to reconstruct a slice for a set of center of rotation value. Interface to nabu multicor
+"""
+
+from __future__ import annotations
 
 import argparse
 import logging
 import signal
 import sys
 import time
-from typing import Union
 
 import silx
 from silx.gui import qt
@@ -122,7 +125,7 @@ class SAAxisWindow(_SAAxisWindow):
     def stop(self):
         self._stopProcessingThread()
 
-    def _computeEstimatedCor(self) -> Union[float, None]:
+    def _computeEstimatedCor(self) -> float | None:
         scan = self.getScan()
         if scan is None:
             return

tomwer/app/multipag.py

@@ -1,12 +1,15 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+"""Application to reconstruct a slice with Paganin for a set of delta/beta values.
+"""
+
+from __future__ import annotations
 
 import argparse
 import logging
 import signal
 import sys
 import time
-from typing import Union
 
 import silx
 from silx.gui import qt
@@ -20,6 +23,10 @@ from tomwer.core.process.reconstruction.darkref.darkrefs import (
 from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
     SADeltaBetaTask,
 )
+from tomwer.core.process.reconstruction.utils.cor import (
+    relative_pos_to_absolute,
+    absolute_pos_to_relative,
+)
 from tomwer.core.process.task import Task
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.resource import increase_max_number_file
@@ -133,13 +140,17 @@ class SADeltaBetaWindow(_SADeltaBetaWindow):
 
     def _relativeValueEdited(self):
         old = self._absoluteCORValueQLE.blockSignals(True)
-        value = self._relativeCORValueQLE.value() + self._imageWidth / 2.0
+        value = relative_pos_to_absolute(
+            relative_pos=self._relativeCORValueQLE.value(), det_width=self._imageWidth
+        )
         self._absoluteCORValueQLE.setValue(value)
         self._absoluteCORValueQLE.blockSignals(old)
 
-    def _absolueValueEdited(self):
+    def _absoluteValueEdited(self):
         old = self._relativeCORValueQLE.blockSignals(True)
-        value = self._absoluteCORValueQLE.value() - self._imageWidth / 2.0
+        value = absolute_pos_to_relative(
+            absolute_pos=self._absoluteCORValueQLE.value(), det_width=self._imageWidth
+        )
         self._relativeCORValueQLE.setValue(value)
         self._relativeCORValueQLE.blockSignals(old)
 
@@ -200,7 +211,7 @@ class SADeltaBetaWindow(_SADeltaBetaWindow):
     def stop(self):
         self._stopProcessingThread()
 
-    def _computeEstimatedCor(self) -> Union[float, None]:
+    def _computeEstimatedCor(self) -> float | None:
         scan = self.getScan()
         if scan is None:
             return

tomwer/app/nabuapp.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
+"""Application to reconstruct a slice with nabu
+"""
 import argparse
 import logging
 import signal

tomwer/app/nxtomoeditor.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+"""Application to edit several entries of a NXtomo
+"""
 
 import argparse
 import logging
@@ -9,6 +11,7 @@ import sys
 from silx.gui import qt
 
 from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.process.edit.nxtomoeditor import NXtomoEditorTask
 from tomwer.gui.edit.nxtomoeditor import NXtomoEditorDialog as _NXtomoEditorDialog
 from tomwer.gui.utils.splashscreen import getMainSplashScreen
 
@@ -21,18 +24,20 @@ class NXtomoEditorDialog(_NXtomoEditorDialog):
         super().__init__()
 
         # connect signal / slot
-        self._buttons.button(qt.QDialogButtonBox.Ok).released.connect(
-            self._overwriteNXtomo
-        )
+        self._buttons.button(qt.QDialogButtonBox.Ok).released.connect(self._triggerTask)
+
+    def getScan(self):
+        return self.mainWidget.getScan()
 
-    def _overwriteNXtomo(self, *args, **kwargs):
-        print("start overwrite")
-        try:
-            self.overwriteNXtomo()
-        except Exception as e:
-            print(f"write failed with error {e}")
-        else:
-            print("overwrite succeded")
+    def _triggerTask(self, *args, **kwargs):
+        task = NXtomoEditorTask(
+            inputs={
+                "data": self.getScan(),
+                "configuration": self.getConfigurationForTask(),
+            }
+        )
+        task.run()
+        print("edition finished")
 
 
 def main(argv):
@@ -78,7 +83,7 @@ def main(argv):
         )
     except Exception as e:
         _logger.error(
-            f"Fail to find an NXtomo from {options.scan_path} at {options.entry}. Error is {e}"
+            f"Fail to find a NXtomo from {options.scan_path} at {options.entry}. Error is {e}"
         )
         return
 

tomwer/app/patchrawdarkflat.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+"""Application to append dark of flat frames to an existing NXtomo
+"""
 
 import argparse
 import logging

tomwer/app/radiostack.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
+"""Application to display scan radios as a stack
+"""
 import argparse
 import logging
 import os
@@ -21,7 +22,7 @@ _logger = logging.getLogger(__name__)
 
 
 def getinputinfo():
-    return "tomwer radiostack [scanDir]"
+    return "tomwer radio-stack [scanName]"
 
 
 def addFolderAndSubFolder(stack, path):

tomwer/app/reducedarkflat.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+"""Application to compute reduced darks and flats for a given scan
+"""
 
 import argparse
 import logging
@@ -60,6 +62,7 @@ def _exec_with_interaction(scan, dark_method, flat_method, overwrite):
 
     class _DarkRefWidgetRunnable(DarkRefWidget):
         sigScanReady = qt.Signal(str)
+        """emit when scan ready"""
 
         def __init__(self, scan, parent=None):
             self.__scan = scan