tomwer 1.2.0a1__py3-none-any.whl → 1.2.0a3__py3-none-any.whl

orangecontrib/tomwer/widgets/visualization/SliceStackOW.py

@@ -32,6 +32,7 @@ import logging
 
 from orangewidget import gui, widget
 from orangewidget.widget import Input
+
 from silx.gui import qt
 
 import tomwer.core.process.visualization.slicestack
@@ -75,15 +76,16 @@ class SlicesStackOW(widget.OWBaseWidget, openclass=True):
 
     ewokstaskclass = tomwer.core.process.visualization.slicestack._SliceStackPlaceHolder
 
-    allows_cycle = True
-    compress_signal = False
-
     want_main_area = True
     want_control_area = False
     resizing_enabled = True
 
     class Inputs:
-        data = Input(name="data", type=TomwerScanBase)
+        data = Input(
+            name="data",
+            type=TomwerScanBase,
+            multiple=True,
+        )
 
     def __init__(self, parent=None):
         widget.OWBaseWidget.__init__(self, parent)
@@ -92,7 +94,7 @@ class SlicesStackOW(widget.OWBaseWidget, openclass=True):
         self._box.layout().addWidget(self._viewer)
 
     @Inputs.data
-    def addLeafScan(self, scanID):
+    def addLeafScan(self, scanID, *args, **kwargs):
         if scanID is None:
             return
         self._viewer.addLeafScan(scanID)

orangecontrib/tomwer/widgets/visualization/VolumeViewerOW.py

@@ -30,6 +30,7 @@ __date__ = "21/07/2020"
 import pytest
 from orangewidget import gui, widget
 from orangewidget.widget import Input
+
 from silx.gui import qt
 
 import tomwer.core.process.visualization.volumeviewer
@@ -60,20 +61,19 @@ class VolumeViewerOW(widget.OWBaseWidget, openclass=True):
     want_main_area = True
     want_control_area = False
     resizing_enabled = True
-    compress_signal = False
 
     class Inputs:
         data = Input(name="data", type=TomwerScanBase)
-        volume = Input(name="volume", type=TomwerVolumeBase)
+        volume = Input(name="volume", type=TomwerVolumeBase, multiple=True)
 
     def __init__(self, parent=None):
-        widget.OWBaseWidget.__init__(self, parent)
+        super().__init__(parent)
         self._layout = gui.vBox(self.mainArea, self.name).layout()
         self.viewer = VolumeViewer(parent=self)
         self._layout.addWidget(self.viewer)
 
     @Inputs.data
-    def addScan(self, scan):
+    def addScan(self, scan, *args, **kwargs):
         if scan is None:
             return
         self.viewer.setScan(scan)

tomwer/__main__.py

@@ -36,9 +36,125 @@ __date__ = "10/11/2020"
 
 
 import sys
-
+import logging
+import traceback
+from collections import namedtuple
 import tomwer.version
-from tomwer.utils import Launcher
+from tomwer.utils import Launcher as _Launcher
+
+
+DeprecationWarning = namedtuple(
+    "DeprecationWarning", ["since", "reason", "replacement"]
+)
+
+
+depreclog = logging.getLogger("nxtomomill.DEPRECATION")
+
+
+class Launcher(_Launcher):
+    """
+    Manage launch of module.
+
+    Provides an API to describe available commands and feature to display help
+    and execute the commands.
+    """
+
+    def __init__(
+        self, prog=None, usage=None, description=None, epilog=None, version=None
+    ):
+        super().__init__(
+            prog=prog,
+            usage=usage,
+            description=description,
+            epilog=epilog,
+            version=version,
+        )
+        self._deprecations = {}
+        "deprecations with prog names as key and deprecation info as values"
+
+    def add_command(
+        self,
+        name=None,
+        module_name=None,
+        description=None,
+        command=None,
+        deprecated=False,
+        deprecated_since_version=None,
+        deprecated_reason=None,
+        deprecated_replacement=None,
+    ):
+        super().add_command(
+            name=name, module_name=module_name, description=description, command=command
+        )
+        if deprecated:
+            self._deprecations[name] = DeprecationWarning(
+                since=deprecated_since_version,
+                reason=deprecated_reason,
+                replacement=deprecated_replacement,
+            )
+
+    def execute(self, argv=None):
+        if argv is None:
+            argv = sys.argv
+
+        if len(argv) <= 1:
+            self.print_help()
+            return 0
+
+        command_name = argv[1]
+
+        if command_name in self._deprecations:
+            deprecation_info = self._deprecations[command_name]
+            deprecated_warning(
+                type_="application",
+                name=command_name,
+                reason=deprecation_info.reason,
+                replacement=deprecation_info.replacement,
+                since_version=deprecation_info.since,
+            )
+        super().execute(argv=argv)
+
+
+def deprecated_warning(
+    type_,
+    name,
+    reason=None,
+    replacement=None,
+    since_version=None,
+    skip_backtrace_count=0,
+):
+    """
+    Function to log a deprecation warning
+
+    :param str type_: Nature of the object to be deprecated:
+        "Module", "Function", "Class" ...
+    :param name: Object name.
+    :param str reason: Reason for deprecating this function
+        (e.g. "feature no longer provided",
+    :param str replacement: Name of replacement function (if the reason for
+        deprecating was to rename the function)
+    :param str since_version: First *silx* version for which the function was
+        deprecated (e.g. "0.5.0").
+    :param int skip_backtrace_count: Amount of last backtrace to ignore when
+        logging the backtrace
+    """
+    if not depreclog.isEnabledFor(logging.WARNING):
+        # Avoid computation when it is not logged
+        return
+
+    msg = "%s %s is deprecated"
+    if since_version is not None:
+        msg += " since silx version %s" % since_version
+    msg += "."
+    if reason is not None:
+        msg += " Reason: %s." % reason
+    if replacement is not None:
+        msg += " Use '%s' instead." % replacement
+    msg += "\n%s"
+    limit = 2 + skip_backtrace_count
+    backtrace = "".join(traceback.format_stack(limit=limit)[0])
+    backtrace = backtrace.rstrip()
+    depreclog.warning(msg, type_, name, backtrace)
 
 
 def main():
@@ -63,13 +179,21 @@ def main():
     )
     launcher.add_command(
         "dark-ref",
-        module_name="tomwer.app.darkref",
+        module_name="tomwer.app.reducedarkflat",
         description="Compute mean / median darks and flat fields",
+        deprecated=True,
+        deprecated_reason="improve name",
+        deprecated_replacement="reduce-dark-flat",
+        deprecated_since_version=1.2,
     )
     launcher.add_command(
         "dark-ref-patch",
-        module_name="tomwer.app.darkrefpatch",
-        description="patch dark and / or flat to an NXTomo entry",
+        module_name="tomwer.app.patchrawdarkflat",
+        description="patch raw dark and / or flat to an NXTomo entry",
+        deprecated=True,
+        deprecated_reason="improve name",
+        deprecated_replacement="patch-raw-dark-flat",
+        deprecated_since_version=1.2,
     )
     launcher.add_command(
         "diff-frame",
@@ -116,6 +240,16 @@ def main():
         module_name="tomwer.app.ows_to_script",
         description="Convert a .ows file to python script",
     )
+    launcher.add_command(
+        "patch-raw-dark-flat",
+        module_name="tomwer.app.patchrawdarkflat",
+        description="patch raw dark and / or flat to an NXTomo entry",
+    )
+    launcher.add_command(
+        "reduce-dark-flat",
+        module_name="tomwer.app.reducedarkflat",
+        description="Compute reduce darks / flats (mean / median of raw darks and flats)",
+    )
     launcher.add_command(
         "rsync",
         module_name="tomwer.app.rsync",

tomwer/app/axis.py

@@ -11,7 +11,7 @@ from silx.gui import qt
 
 from tomwer.core.process.reconstruction.axis.axis import (
     AxisMode,
-    AxisProcess,
+    AxisTask,
     NoAxisUrl,
 )
 from tomwer.core.process.reconstruction.darkref.darkrefs import (
@@ -29,9 +29,9 @@ _logger = logging.getLogger(__name__)
 
 
 class _AxisProcessGUI(AxisWindow):
-    def __init__(self, scan, axis_params):
+    def __init__(self, scan, axis_params, backend=None):
         axis_params.frame_width = scan.dim_1
-        AxisWindow.__init__(self, axis_params=axis_params)
+        super().__init__(axis_params=axis_params, backend=backend)
         self.hideLockButton()
         self.hideApplyButton()
         self.setScan(scan=scan)
@@ -46,11 +46,12 @@ class _AxisProcessGUI(AxisWindow):
             ("start axis calculation with", scan.axis_params.axis_url_1.url.path())
         )
         _logger.info(mess)
-        process = AxisProcess(
+        process = AxisTask(
             inputs={
                 "data": scan,
                 "axis_params": self._axis_params,
                 "wait": wait,
+                "serialize_output_data": False,
             }
         )
         try:
@@ -111,12 +112,22 @@ def main(argv):
         default=False,
         help="Define the mode 'full' when display shifted images from manual" " mode",
     )
-
+    parser.add_argument(
+        "--use-opengl-plot",
+        help="Use OpenGL for plots (instead of matplotlib)",
+        action="store_true",
+        default=False,
+    )
     options = parser.parse_args(argv[1:])
 
     if options.debug:
         logging.root.setLevel(logging.DEBUG)
 
+    if options.use_opengl_plot:
+        import silx
+
+        silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     increase_max_number_file()
 
     global app  # QApplication must be global to avoid seg fault on quit

tomwer/app/canvas_launcher/config.py

@@ -129,7 +129,7 @@ class TomwerConfig(config.Config):
         "Quick Start": "https://www.youtube.com/playlist?list=PLddRXwP6Z6F9KOu1V5o6H24KPH5Ikuk2f",
         #: The 'full' documentation, should be something like current /docs/
         #: but specific for 'Visual Programing' only
-        "Documentation": "https://tomotools.gitlab-pages.esrf.fr/nxtomomill/index.html",
+        "Documentation": "https://tomotools.gitlab-pages.esrf.fr/tomwer/index.html",
         #: YouTube tutorials
         "Screencasts": "https://www.youtube.com/@tomotools",
     }

tomwer/app/canvas_launcher/mainwindow.py

@@ -4,6 +4,7 @@ import os
 import shutil
 import signal
 import sys
+from typing import List
 from contextlib import closing
 from logging.handlers import RotatingFileHandler
 from urllib.request import urlopen
@@ -27,6 +28,9 @@ 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
+
 
 from .config import TomwerConfig, TomwerSplashScreen
 
@@ -54,6 +58,8 @@ LOG_FOLDER = "/var/log/tomwer"
 
 
 class MainWindow(_MainWindow):
+    HELPDESK_URL = "https://requests.esrf.fr/plugins/servlet/desk/portal/41"
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.process_supervisor_dock = DockWidget(
@@ -85,12 +91,143 @@ class MainWindow(_MainWindow):
         super().setup_menu()
         self.view_menu.addAction(self.show_processes_manager_action)
 
-    def open_about(self):
-        # type: () -> None
-        """Open the about dialog."""
-        dlg = AboutDialog(self)
-        dlg.setAttribute(qt.Qt.WA_DeleteOnClose)
-        dlg.exec()
+        self.simple_example_action = qt.QAction(
+            self.tr("simple use cases"),
+            self,
+            objectName="simple-use-cases",
+            toolTip=self.tr("Some simple examples."),
+            triggered=self.open_simple_examples,
+            menuRole=qt.QAction.AboutRole,
+        )
+
+        self.dark_flat_example_action = qt.QAction(
+            self.tr("darks and flats manipulations"),
+            self,
+            objectName="dark-flat-manipulation",
+            toolTip=self.tr("Examples around dark and flat."),
+            triggered=self.open_dark_flat_examples,
+            menuRole=qt.QAction.AboutRole,
+        )
+        self.slurm_execution_example_action = qt.QAction(
+            self.tr("remote processing with slurm"),
+            self,
+            objectName="execution-on-slurm",
+            toolTip=self.tr("Examples of some execution over slurm."),
+            triggered=self.open_slurm_execution_example,
+            menuRole=qt.QAction.AboutRole,
+        )
+        self.cor_search_example_action = qt.QAction(
+            self.tr("cor search advance example"),
+            self,
+            objectName="cor-search-example",
+            toolTip=self.tr("Examples of ways to search for the Center of rotation."),
+            triggered=self.open_cor_search_example,
+            menuRole=qt.QAction.AboutRole,
+        )
+        self.python_script_example_action = qt.QAction(
+            self.tr("python script examples"),
+            self,
+            objectName="python-script-example",
+            toolTip=self.tr("Examples of some python script usage."),
+            triggered=self.open_python_script_example,
+            menuRole=qt.QAction.AboutRole,
+        )
+        # Predefined workflows menu.
+        self.predefined_workflows_menu = qt.QMenu(
+            self.tr("&Examples"),
+            self.menuBar(),
+            objectName="examples-menu",
+        )
+        self.predefined_workflows_menu.addActions(
+            [
+                self.simple_example_action,
+                self.cor_search_example_action,
+                self.dark_flat_example_action,
+                self.slurm_execution_example_action,
+                self.python_script_example_action,
+            ]
+        )
+
+        self.menuBar().addMenu(self.predefined_workflows_menu)
+
+        self._helpdeskButton = qt.QAction(
+            self.tr("&Helpdesk"),
+            self,
+            objectName="helpdeskButton",
+            triggered=self._contactUs,
+            toolTip="contact esrf data processing helpdesk if you have some troubles with the application",
+        )
+        self.menuBar().addAction(self._helpdeskButton)
+
+    def _contactUs(self, *args, **kwargs):
+        try:
+            qt.QDesktopServices.openUrl(qt.QUrl(self.HELPDESK_URL))
+        except Exception as e:
+            _logger.error(
+                f"Failed to launch helpdesk web page ({self.HELPDESK_URL}). Error is {e}"
+            )
+
+    def __open_examples(self, examples, filter_names=None):
+        """
+        filter the existing tutorials by names contained in the file name
+        """
+        items = [previewmodel.PreviewItem(path=t.abspath()) for t in examples]
+
+        def my_filter(value):
+            for filter_name in filter_names:
+                if filter_name in value:
+                    return True
+            return False
+
+        if filter_names is not None:
+            items = filter(
+                lambda item: my_filter(os.path.basename(item.path())),
+                items,
+            )
+        dialog = previewdialog.PreviewDialog(self)
+        model = previewmodel.PreviewModel(dialog, items=items)
+        title = self.tr("Example Workflows")
+        dialog.setWindowTitle(title)
+        template = '<h3 style="font-size: 26px">\n' "{0}\n" "</h3>"
+
+        dialog.setHeading(template.format(title))
+        dialog.setModel(model)
+
+        model.delayedScanUpdate()
+        status = dialog.exec()
+        index = dialog.currentIndex()
+
+        dialog.deleteLater()
+
+        if status == qt.QDialog.Accepted:
+            selected = model.item(index)
+            self.open_example_scheme(selected.path())
+        return status  # def open_about(self):
+
+    def open_simple_examples(self):
+        return self.__open_examples(
+            orange_examples.workflows(), filter_names=("simple", "EBS_tomo_listener")
+        )
+
+    def open_slurm_execution_example(self):
+        return self.__open_examples(
+            orange_examples.workflows(), filter_names=("slurm",)
+        )
+
+    def open_dark_flat_examples(self):
+        return self.__open_examples(
+            orange_examples.workflows(), filter_names=("darks",)
+        )
+
+    def open_python_script_example(self):
+        return self.__open_examples(
+            orange_examples.workflows(), filter_names=("_script",)
+        )
+
+    def open_cor_search_example(self):
+        return self.__open_examples(
+            orange_examples.workflows(), filter_names=("find_cor", "cor_search")
+        )
 
 
 log = logging.getLogger(__name__)
@@ -125,12 +262,33 @@ class _OMain(ocMain):
         signal.signal(signal.SIGINT, signal.SIG_DFL)
         # Disable pyqtgraph's atexit and QApplication.aboutToQuit cleanup handlers.
         pyqtgraph.setConfigOption("exitCleanup", False)
+        print("argv are", argv)
         super().run(argv)
 
     def argument_parser(self) -> argparse.ArgumentParser:
         parser = super().argument_parser()
+        parser.add_argument(
+            "--use-opengl-plot",
+            help="Use OpenGL for plots (instead of matplotlib)",
+            action="store_true",
+            default=False,
+        )
         return parser
 
+    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.
+        # this way we should also be able to let the user define it
+        # on it's own later...
+        if self.options.use_opengl_plot:
+            import silx
+
+            # other standalones are not passing by the silx.config
+            # but for the canvas this is way simpler to use it.
+            # then all plot which have backend==None will pick the default plot backend
+            silx.config.DEFAULT_PLOT_BACKEND = "gl"
+
     def setup_logging(self):
         super().setup_logging()
         make_sql_logger(self.options.log_level)