tomwer 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

orangecontrib/tomwer/widgets/control/NXTomomillOW.py

@@ -27,53 +27,29 @@ __authors__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "11/03/2020"
 
+import os
+import logging
+from copy import copy
 from silx.gui import qt
-from orangewidget import widget, gui
+from orangewidget import gui
 from tomwer.gui.control.datalist import BlissHDF5DataListMainWindow
+from orangecontrib.tomwer.orange.managedprocess import TomwerWithStackStack
 from tomwer.core.scan.hdf5scan import HDF5TomoScan, HDF5TomoScanIdentifier
-from tomwer.web.client import OWClient
 from tomwer.core.process.control.nxtomomill import H5ToNxProcess
-import tomwer.core.process.control.nxtomomill
-from orangewidget.settings import Setting
-from orangewidget.widget import Output, Input
-from tomwer.core.scan.scanbase import TomwerScanBase
+from orangecontrib.tomwer.widgets.control.NXTomomillMixIn import NXTomomillMixIn
 from tomwer.core.scan.blissscan import BlissScan
-from nxtomomill import converter as nxtomomill_converter
 from nxtomomill.io.config import TomoHDF5Config as HDF5Config
-from tomwer.gui.control.nxtomomill import NXTomomillInput, OverwriteMessage
-import os
-import logging
+from tomwer.gui.control.nxtomomill import OverwriteMessage
+from tomwer.gui.control.nxtomomill import NXTomomillInput
 
 logger = logging.getLogger(__name__)
 
 
-class _NXTomoMixIn:
-    _scans = Setting(list())
-
-    _nxtomo_cfg_file = Setting(str())
-    # to keep bacard compatibility (for NXTomomillOW)
-
-    _static_input = Setting(dict())
-
-    def _saveNXTomoCfgFile(self, cfg_file):
-        """save the nxtomofile to the setttings"""
-        self._nxtomo_cfg_file = cfg_file
-        self._static_input["nxtomomill_cfg_file"] = cfg_file
-
-    def _updateSettings(self):
-        self._scans = []
-        for scan in self.widget.datalist._myitems:
-            # kept for backward compatibility since 0.11. To be removed on the future version.
-            if "@" in scan:
-                entry, file_path = scan.split("@")
-                hdf5_tomo_scan = HDF5TomoScan(entry=entry, scan=file_path)
-                self.add(hdf5_tomo_scan)
-            else:
-                self._scans.append(scan)
-        self._static_input["output_dir"] = self.widget.getOutputFolder()
-
-
-class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
+class NXTomomillOW(
+    TomwerWithStackStack,
+    NXTomomillMixIn,
+    ewokstaskclass=H5ToNxProcess,
+):
     """
     Widget to allow user to pick some bliss files and that will convert them
     to HDF5scan.
@@ -104,21 +80,17 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
     resizing_enabled = True
     compress_signal = False
 
-    ewokstaskclass = tomwer.core.process.control.nxtomomill.H5ToNxProcess
+    CONFIG_CLS = HDF5Config
 
-    class Inputs:
-        data = Input(name="bliss data", type=BlissScan, doc="bliss scan to be process")
-
-    class Outputs:
-        data = Output(name="data", type=TomwerScanBase, doc="one scan to be process")
+    LOGGER = logger
 
     def __init__(self, parent=None):
-        widget.OWBaseWidget.__init__(self, parent)
-        OWClient.__init__(self)
-        _NXTomoMixIn.__init__(self)
+        TomwerWithStackStack.__init__(self, parent=parent)
+        NXTomomillMixIn.__init__(self)
+        _layout = gui.vBox(self.mainArea, self.name).layout()
+
         self.widget = BlissHDF5DataListMainWindow(parent=self)
-        layout = gui.vBox(self.mainArea, self.name).layout()
-        layout.addWidget(self.widget)
+        _layout.addWidget(self.widget)
         self.__request_input = True
         # do we ask the user for input if missing
         self._inputGUI = None
@@ -127,7 +99,6 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
         """Cache to know if we have to ask user permission for overwriting"""
 
         # expose API
-        self.add = self.widget.add
         self.n_scan = self.widget.n_scan
         # alias used for the 'simple workflow' for now
         self.start = self._sendAll
@@ -137,9 +108,30 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
         self.widget._sendSelectedButton.clicked.connect(self._sendSelected)
         self.widget.sigNXTomoCFGFileChanged.connect(self._saveNXTomoCfgFile)
         self.widget.sigUpdated.connect(self._updateSettings)
+
+        # set default configuration is no existing configuration file defined in the settings
+        self.update_default_inputs(
+            h5_to_nx_configuration=HDF5Config().to_dict(),
+        )
+        self.task_output_changed_callbacks.add(self._notify_state)
+
         # handle settings
         self._loadSettings()
 
+    def _updateSettings(self):
+        self._scans = []
+        for scan in self.widget.datalist._myitems:
+            # kept for backward compatibility since 0.11. To be removed on the future version.
+            if "@" in scan:
+                entry, file_path = scan.split("@")
+                hdf5_tomo_scan = HDF5TomoScan(entry=entry, scan=file_path)
+                self.add(hdf5_tomo_scan)
+            else:
+                self._scans.append(scan)
+        self._ewoks_default_inputs[  # pylint: disable=E1137
+            "output_dir"
+        ] = self.widget.getOutputFolder()
+
     @property
     def request_input(self):
         return self.__request_input
@@ -148,42 +140,57 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
     def request_input(self, request):
         self.__request_input = request
 
-    def _sendSelected(self):
-        """Send a signal for selected scans found to the next widget"""
-        self._inputGUI = NXTomomillInput()
-        # reset the GUI for input (reset all the cache for answers)
-        self._canOverwriteOutputs = False
-        for bliss_url in self.widget.datalist.selectedItems():
-            identifier = HDF5TomoScanIdentifier.from_str(bliss_url.text())
-            self._inputGUI.setBlissScan(
-                entry=identifier.data_path, file_path=identifier.file_path
-            )
-            self._process(bliss_url.text())
+    def get_task_inputs(self):
+        return {
+            "h5_to_nx_configuration": self.__configuration_cache.to_dict(),
+        }
 
-    def _sendAll(self):
-        """Send a signal for each scan found to the next widget"""
-        self._inputGUI = NXTomomillInput()
-        # reset the GUI for input (reset all the cache for answers)
-        self._canOverwriteOutputs = False
-        for bliss_url in self.widget.datalist.selectedItems():
-            identifier = HDF5TomoScanIdentifier.from_str(bliss_url.text())
-            self._inputGUI.setBlissScan(
-                entry=identifier.data_path, file_path=identifier.file_path
-            )
-            self._process(bliss_url.text())
+    def handleNewSignals(self) -> None:
+        """Invoked by the workflow signal propagation manager after all
+        signals handlers have been called.
+        """
+        # for now we want to avoid propagation any processing.
+        # task will be executed only when the user validates the dialog
+        h5_scan = super().get_task_inputs().get("hdf5_scan", None)
+        if h5_scan is not None:
+            if not isinstance(h5_scan, H5ToNxProcess):
+                raise TypeError(
+                    "hdf5_scan is expected to be an instance of HDF5TomoScan"
+                )
+            self.add(h5_scan.path)
 
-    def _process(self, bliss_url):
+    def _convertAndSend(self, bliss_url):
         """
 
         :param str bliss_url: string at entry@file format
         """
         logger.processStarted("Start translate {} to NXTomo".format(str(bliss_url)))
+        self.__configuration_cache = HDF5Config.from_dict(
+            copy(self.get_default_input_values()["h5_to_nx_configuration"])
+        )
+
         identifier = HDF5TomoScanIdentifier.from_str(bliss_url)
         bliss_scan = BlissScan(
             master_file=identifier.file_path,
             entry=identifier.data_path,
             proposal_file=None,
         )
+
+        output_file_path = H5ToNxProcess.deduce_output_file_path(
+            bliss_scan.master_file,
+            entry=bliss_scan.entry,
+            outputdir=self.widget.getOutputFolder(),
+            scan=bliss_scan,
+        )
+
+        self.__configuration_cache.input_file = bliss_scan.master_file
+        self.__configuration_cache.output_file = output_file_path
+        self.__configuration_cache.entries = (bliss_scan.entry,)
+        self.__configuration_cache.single_file = False
+        self.__configuration_cache.overwrite = True
+        self.__configuration_cache.request_input = self.request_input
+        self.__configuration_cache.file_extension = ".nx"
+
         self._processBlissScan(bliss_scan)
 
     def _userAgreeForOverwrite(self, file_path):
@@ -199,10 +206,6 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
             else:
                 return False
 
-    @Inputs.data
-    def treatBlissScan(self, bliss_scan):
-        self._processBlissScan(bliss_scan)
-
     def _processBlissScan(self, bliss_scan):
         if bliss_scan is None:
             return
@@ -210,16 +213,14 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
             bliss_scan.master_file,
             entry=bliss_scan.entry,
             outputdir=self.widget.getOutputFolder(),
+            scan=bliss_scan,
         )
         # check user has rights to write on the folder
         dirname = os.path.dirname(output_file_path)
-        if not os.access(dirname, os.W_OK):
+        if os.path.exists(dirname) and not os.access(dirname, os.W_OK):
             msg = qt.QMessageBox(self)
             msg.setIcon(qt.QMessageBox.Warning)
-            text = (
-                "You don't have write rights on {}. Unable to generate "
-                "the nexus file associated to {}".format(dirname, str(bliss_scan))
-            )
+            text = f"You don't have write rights on '{dirname}'. Unable to generate the nexus file associated to {str(bliss_scan)}"
             msg.setWindowTitle("No rights to write")
             msg.setText(text)
             msg.show()
@@ -229,43 +230,11 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
             if not self._userAgreeForOverwrite(output_file_path):
                 return
 
-        configuration = self.getHDF5Config()
-        if configuration is None:
-            return
-
-        # TODO: management of inputs from url: do we want to ignore urls
-        # provided ? Or check if the entry receive fit
-        # one provided (a root entry for now)
-        # force some parameters
-        configuration.input_file = bliss_scan.master_file
-        configuration.output_file = output_file_path
-        configuration.entries = (bliss_scan.entry,)
-        configuration.single_file = False
-        configuration.overwrite = True
-        configuration.request_input = self.request_input
-        configuration.file_extension = ".nx"
-        if hasattr(configuration, "bam_single_file"):
-            configuration.bam_single_file = True
-        try:
-            convs = nxtomomill_converter.from_h5_to_nx(
-                configuration=configuration,
-                input_callback=self._inputGUI,
-                progress=None,
-            )
-        except Exception as e:
-            logger.processFailed(
-                "Fail to convert from bliss file: %s to NXTomo."
-                "Conversion error is: %s" % (bliss_scan, e)
-            )
-        else:
-            # in the case of zserie we can have several scan for one entry
-            for conv in convs:
-                conv_file, conv_entry = conv
-                scan_converted = HDF5TomoScan(scan=conv_file, entry=conv_entry)
-                logger.processSucceed(
-                    "{} has been translated to {}" "".format(bliss_scan, scan_converted)
-                )
-                self.Outputs.data.send(scan_converted)
+        # keep 'h5_to_nx_configuration' up to date according to input folder and output_file updates
+        self.update_default_inputs(
+            h5_to_nx_configuration=self.__configuration_cache.to_dict()
+        )
+        self._execute_ewoks_task(propagate=True)
 
     def _loadSettings(self):
         for scan in self._scans:
@@ -276,13 +245,15 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
                 logger.error("Fail to add {}. Error is {}".format(scan, e))
             else:
                 logger.warning("{} is an invalid link to a file".format(scan))
-        if "nxtomomill_cfg_file" in self._static_input:
-            nxtomo_cfg_file = self._static_input["nxtomomill_cfg_file"]
-        else:
-            nxtomo_cfg_file = self._nxtomo_cfg_file
-        self.widget.setCFGFilePath(nxtomo_cfg_file)
-        if "output_dir" in self._static_input:
-            self.widget.setOutputFolder(self._static_input["output_dir"])
+        if "nxtomomill_cfg_file" in self._ewoks_default_inputs:  # pylint: disable=E1135
+            nxtomo_cfg_file = self._ewoks_default_inputs[  # pylint: disable=E1136
+                "nxtomomill_cfg_file"
+            ]
+            self.widget.setCFGFilePath(nxtomo_cfg_file)
+        if "output_dir" in self._ewoks_default_inputs:  # pylint: disable=E1135
+            self.widget.setOutputFolder(
+                self._ewoks_default_inputs["output_dir"]  # pylint: disable=E1136
+            )
 
     def getHDF5Config(self):
         configuration_file = self.widget.getCFGFilePath()
@@ -301,6 +272,42 @@ class NXTomomillOW(widget.OWBaseWidget, _NXTomoMixIn, OWClient, openclass=True):
         return configuration
 
     def _saveNXTomoCfgFile(self, cfg_file):
-        super()._saveNXTomoCfgFile(cfg_file)
-        if os.path.exists(cfg_file):
-            self.widget.setConfiguration(HDF5Config.from_cfg_file(cfg_file))
+        super()._saveNXTomoCfgFile(cfg_file, keyword="h5_to_nx_configuration")
+
+    def _sendSelected(self):
+        """Send a signal for selected scans found to the next widget"""
+        self._inputGUI = NXTomomillInput()
+        # reset the GUI for input (reset all the cache for answers)
+        self._canOverwriteOutputs = False
+        for bliss_url in self.widget.datalist.selectedItems():
+            identifier = HDF5TomoScanIdentifier.from_str(bliss_url.text())
+            self._inputGUI.setBlissScan(
+                entry=identifier.data_path, file_path=identifier.file_path
+            )
+            self._convertAndSend(bliss_url.text())
+
+    def _sendAll(self):
+        """Send a signal for each scan found to the next widget"""
+        self._inputGUI = NXTomomillInput()
+        # reset the GUI for input (reset all the cache for answers)
+        self._canOverwriteOutputs = False
+        for bliss_url in self.widget.datalist.selectedItems():
+            identifier = HDF5TomoScanIdentifier.from_str(bliss_url.text())
+            self._inputGUI.setBlissScan(
+                entry=identifier.data_path, file_path=identifier.file_path
+            )
+            self._convertAndSend(bliss_url.text())
+
+    def _notify_state(self):
+        try:
+            task_executor = self.sender()
+            task_suceeded = task_executor.succeeded
+            config = task_executor.current_task.inputs.h5_to_nx_configuration
+            config = HDF5Config.from_dict(config)
+            scan = task_executor.current_task.outputs.data
+            if task_suceeded:
+                self.notify_succeed(scan=scan)
+            else:
+                self.notify_failed(scan=scan)
+        except Exception as e:
+            logger.error(f"failed to handle task finished callback. Raiseon is {e}")

orangecontrib/tomwer/widgets/control/NotifierOW.py

@@ -32,6 +32,7 @@ from silx.gui import qt
 from orangewidget import widget
 from orangewidget.widget import Input, Output
 from tomwer.core.tomwer_object import TomwerObject
+from orangewidget import settings
 
 
 class NotifierWidgetOW(widget.OWBaseWidget):
@@ -50,6 +51,8 @@ class NotifierWidgetOW(widget.OWBaseWidget):
     resizing_enabled = False
     compress_signal = False
 
+    _muted = settings.Setting(False)
+
     class Inputs:
         tomo_obj = Input(name="tomo_obj", type=TomwerObject, multiple=True)
 
@@ -60,19 +63,44 @@ class NotifierWidgetOW(widget.OWBaseWidget):
         super().__init__(parent)
         self.pop_up = None
         layout = gui.vBox(self.mainArea, self.name).layout()
-        self.label = qt.QLabel(parent=self)
-        self.label.setMinimumSize(300, 200)
-        layout.addWidget(self.label)
+        self._soundButton = qt.QPushButton(parent=self)
+        self._soundButton.setMinimumSize(150, 100)
+        self._soundButton.setCheckable(True)
+        layout.addWidget(self._soundButton)
+        self._updateButtonIcon()
+
+        # connect signal / slot
+        self._soundButton.toggled.connect(self._switchMute)
+
+    def _switchMute(self):
+        self._muted = not self._muted
+
+        self._updateButtonIcon()
 
     @Inputs.tomo_obj
     def process(self, tomo_obj, *args, **kwargs):
         self.notify(tomo_obj)
         self.Outputs.tomo_obj.send(tomo_obj)
 
+    def _updateButtonIcon(self):
+        style = qt.QApplication.style()
+        if self._muted:
+            icon = style.standardIcon(qt.QStyle.SP_MediaVolumeMuted)
+        else:
+            icon = style.standardIcon(qt.QStyle.SP_MediaVolume)
+        self._soundButton.setIcon(icon)
+
     def notify(self, tomo_obj):
         if self.pop_up is not None:
             self.pop_up.close()
 
+        if not self._muted:
+            # emit sound when requested
+            try:
+                qt.QApplication.beep()
+            except Exception:
+                pass
+
         self.pop_up = NotificationMessage()
         text = f"Object {tomo_obj} received."
         self.pop_up.setText(text)
@@ -86,14 +114,10 @@ class NotificationMessage(qt.QMessageBox):
         super().__init__()
         self.setModal(False)
         self.setIcon(qt.QMessageBox.Information)
-        # types = qt.QDialogButtonBox.Ok
-        # self.setStandardButtons(types)
         self.addButton(
             f"Ok - will close automatically after {self.EXPOSITION_TIME / 1000}s",
             qt.QMessageBox.YesRole,
         )
-        # print("self.standardButtons()", self.standardButtons())
-        # self.standardButtons()[0].setText(f"Ok - will close automatically after {self.EXPOSITION_TIME / 1000}s")
 
     def show(self):
         super().show()

orangecontrib/tomwer/widgets/control/SingleTomoObjOW.py

@@ -27,13 +27,12 @@ __authors__ = ["C. Nemoz", "H. Payno"]
 __license__ = "MIT"
 __date__ = "25/08/2022"
 
-from orangewidget import widget, gui
+from orangewidget import gui
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.tomwer_object import TomwerObject
 from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.gui.control.singletomoobj import SingleTomoObj
-from tomwer.web.client import OWClient
 from orangewidget.settings import Setting
 from orangewidget.widget import Output, Input, OWBaseWidget
 import tomoscan.esrf.scan.utils
@@ -43,7 +42,7 @@ import logging
 _logger = logging.getLogger(__name__)
 
 
-class SingleTomoObjOW(OWBaseWidget, OWClient, openclass=True):
+class SingleTomoObjOW(OWBaseWidget, openclass=True):
     name = "single tomo obj"
     id = "orange.widgets.tomwer.control.SingleScanOW.SingleScanOW"
     description = "Definition of a single dataset"
@@ -79,8 +78,7 @@ class SingleTomoObjOW(OWBaseWidget, OWClient, openclass=True):
         )
 
     def __init__(self, parent=None):
-        widget.OWBaseWidget.__init__(self, parent)
-        OWClient.__init__(self)
+        super().__init__(parent)
         self._latest_received_scan = None
         # small work around to keep in scan processing cache and avoid recomputing it if not necessary
         self.widget = SingleTomoObj(parent=self)

orangecontrib/tomwer/widgets/control/TomoObjSerieOW.py

@@ -0,0 +1,85 @@
+# 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.
+#
+# ###########################################################################*/
+
+__authors__ = [
+    "H. Payno",
+]
+__license__ = "MIT"
+__date__ = "12/07/2022"
+
+from orangewidget import gui
+from orangewidget.widget import Output, Input, OWBaseWidget
+from tomoscan.serie import Serie
+from tomwer.core.tomwer_object import TomwerObject
+import tomwer.core.process.control.tomoobjserie
+from tomwer.gui.control.serie.seriecreator import SerieWidgetDialog
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class TomoObjSerieOW(OWBaseWidget, openclass=True):
+    name = "serie of objects"
+    id = "orange.widgets.tomwer.tomoobjserieow"
+    description = "Allow user define a serie of object that will be defined as a Serie (grouped together and can be used within a purpose like stiching)"
+    icon = "icons/tomoobjserie.svg"
+    priority = 55
+    keywords = ["tomography", "selection", "tomwer", "serie", "group"]
+
+    ewokstaskclass = tomwer.core.process.control.tomoobjserie._TomoobjseriePlaceHolder
+
+    want_main_area = True
+    want_control_area = False
+    resizing_enabled = True
+    compress_signal = False
+
+    class Inputs:
+        tomo_obj = Input(name="tomo obj", type=TomwerObject, multiple=True)
+
+    class Outputs:
+        serie = Output(name="serie", type=Serie)
+
+    def __init__(self, parent=None):
+        """ """
+        super().__init__(parent)
+        layout = gui.vBox(self.mainArea, self.name).layout()
+
+        self._widget = SerieWidgetDialog(self)
+        layout.addWidget(self._widget)
+
+        # connect signal / slot
+        self._widget.sigSerieSelected.connect(self._send_serie)
+
+    @Inputs.tomo_obj
+    def addTomoObj(self, tomo_obj, *args, **kwargs):
+        if tomo_obj is not None:
+            self._widget.add(tomo_obj)
+
+    def _send_serie(self, serie: Serie):
+        if not isinstance(serie, Serie):
+            raise TypeError(
+                f"serie is expected to be an instance of {Serie}. Not {type(serie)}"
+            )
+        self.Outputs.serie.send(serie)

orangecontrib/tomwer/widgets/control/VolumeSelector.py

@@ -29,10 +29,10 @@ __authors__ = [
 __license__ = "MIT"
 __date__ = "12/07/2022"
 
+from silx.gui import qt
 from orangewidget import gui
 from orangewidget.widget import Output, Input, OWBaseWidget
 from tomwer.core.volume.volumebase import TomwerVolumeBase
-from tomwer.web.client import OWClient
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.gui.control.volumeselectorwidget import VolumeSelectorWidget
 from orangewidget.settings import Setting
@@ -42,7 +42,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-class VolumeSelectorOW(OWBaseWidget, OWClient, openclass=True):
+class VolumeSelectorOW(OWBaseWidget, openclass=True):
     name = "volume selector"
     id = "orange.widgets.tomwer.volumeselector"
     description = (
@@ -72,8 +72,7 @@ class VolumeSelectorOW(OWBaseWidget, OWClient, openclass=True):
 
     def __init__(self, parent=None):
         """ """
-        OWBaseWidget.__init__(self, parent)
-        OWClient.__init__(self)
+        super().__init__(parent)
 
         self.widget = VolumeSelectorWidget(parent=self)
         self._loadSettings()
@@ -128,3 +127,12 @@ class VolumeSelectorOW(OWBaseWidget, OWClient, openclass=True):
         self._scanIDs = []
         for scan in self.widget.dataList._myitems:
             self._scanIDs.append(scan)
+
+    def keyPressEvent(self, event):
+        """
+        To shortcut orange and make sure the `delete` key will be interpreted we need to overwrite this function
+        """
+        if event.key() == qt.Qt.Key_Delete:
+            self.widget._callbackRemoveSelectedDatasets()
+        else:
+            super().keyPressEvent(event)

orangecontrib/tomwer/widgets/control/VolumeSymLinkOW.py

@@ -32,7 +32,6 @@ from silx.gui import qt
 from orangewidget import gui
 
 import tomwer.core.process.control.volumesymlink
-from tomwer.web.client import OWClient
 from orangewidget.settings import Setting
 from orangewidget.widget import Output, Input
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -47,7 +46,7 @@ import logging
 _logger = logging.getLogger(__name__)
 
 
-class VolumeSymLinkOW(SuperviseOW, OWClient):
+class VolumeSymLinkOW(SuperviseOW):
     """
     link volume reconstructed at proposal file if possible else under
     the given folder
@@ -86,8 +85,7 @@ class VolumeSymLinkOW(SuperviseOW, OWClient):
         data = Output(name="data", type=TomwerScanBase, doc="one scan to be process")
 
     def __init__(self, parent=None):
-        SuperviseOW.__init__(self, parent)
-        OWClient.__init__(self)
+        super().__init__(parent)
         self._mainWidget = _OutputDir(parent=self)
         layout = gui.vBox(self.mainArea, self.name).layout()
         layout.addWidget(self._mainWidget)
@@ -96,7 +94,13 @@ class VolumeSymLinkOW(SuperviseOW, OWClient):
     def process(self, scan):
         if scan is None:
             return
-        symlink_process = VolumeSymbolicLinkProcess()
+        symlink_process = VolumeSymbolicLinkProcess(
+            inputs={
+                "data": scan,
+                "output_type": self._mainWidget.getOutputType(),
+                "output_folder": self._mainWidget.getOutputFolder(),
+            }
+        )
         symlink_process.set_configuration(
             {
                 "output_type": self._mainWidget.getOutputType(),
@@ -109,7 +113,7 @@ class VolumeSymLinkOW(SuperviseOW, OWClient):
             state=DatasetState.ON_GOING,
         )
         try:
-            scan = symlink_process.process(scan=scan)
+            symlink_process.run()
         except Exception:
             mess = "Failed to create symbolic link for {}".format(str(scan))
             _logger.processFailed(mess)
@@ -158,7 +162,7 @@ class _OutputDir(qt.QGroupBox):
     def _activeStaticOpt(self, *args, **kwargs):
         self._staticOpt.setChecked(True)
 
-    def _selectFolder(self):
+    def _selectFolder(self):  # pragma: no cover
         dialog = qt.QFileDialog(self)
         dialog.setWindowTitle("Select destination folder for symbolic link")
         dialog.setModal(1)