tomwer 1.2.0a2__py3-none-any.whl → 1.2.0a4__py3-none-any.whl

orangecontrib/tomwer/widgets/control/SingleTomoObjOW.py

@@ -139,9 +139,6 @@ class SingleTomoObjOW(OWBaseWidget, openclass=True):
         if isinstance(data, TomwerScanBase):
             if data.reduced_darks not in (None, {}):
                 reduced_darks = data.reduced_darks
-                reduced_darks[
-                    "reduce_frames_name"
-                ] = f"darks from {data.get_identifier().short_description()}"
                 self.Outputs.reduced_darks.send(reduced_darks)
 
                 # we want to send those in relative position to have something generic. This is a convention for now
@@ -157,9 +154,6 @@ class SingleTomoObjOW(OWBaseWidget, openclass=True):
 
             if data.reduced_flats not in (None, {}):
                 reduced_flats = data.reduced_flats
-                reduced_flats[
-                    "reduce_frames_name"
-                ] = f"flats from {data.get_identifier().short_description()}"
                 self.Outputs.reduced_flats.send(reduced_flats)
 
                 # we want to send those in relative position to have something generic. This is a convention for now

orangecontrib/tomwer/widgets/reconstruction/DarkRefAndCopyOW.py

@@ -246,16 +246,20 @@ class DarkRefAndCopyOW(SuperviseOW, WidgetLongProcessing):
         self.sigScanReady.emit(scan)
         if scan.reduced_darks not in (None, {}):
             # we want to send those in relative position to have something generic. This is a convention for now
+            reduced_darks = scan.reduced_darks
+            reduced_darks.pop("reduce_frames_name", None)
             self.Outputs.reduced_darks.send(
                 tomoscan.esrf.scan.utils.from_absolute_reduced_frames_to_relative(
-                    reduced_frames=scan.reduced_darks, scan=scan
+                    reduced_frames=reduced_darks, scan=scan
                 )
             )
         if scan.reduced_flats not in (None, {}):
             # we want to send those in relative position to have something generic. This is a convention for now
+            reduced_flats = scan.reduced_flats
+            reduced_flats.pop("reduce_frames_name", None)
             self.Outputs.reduced_flats.send(
                 tomoscan.esrf.scan.utils.from_absolute_reduced_frames_to_relative(
-                    reduced_frames=scan.reduced_flats, scan=scan
+                    reduced_frames=reduced_flats, scan=scan
                 )
             )
         _logger.info(f"{scan} ended")

orangecontrib/tomwer/widgets/reconstruction/NabuHelicalPrepareWeightsDoubleOW.py

@@ -1,169 +1,169 @@
-import logging
-
-from orangewidget import gui
-from orangewidget.settings import Setting
-from orangewidget.widget import Input, Output
-from orangecontrib.tomwer.orange.managedprocess import TomwerWithStackStack
-from silx.gui import qt
-from typing import Optional
-
-from tomwer.core.futureobject import FutureTomwerObject
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.gui.reconstruction.nabu.helical import HelicalPrepareWeightsDouble
-from tomwer.core.process.reconstruction.nabu.helical import (
-    NabuHelicalPrepareWeightsDouble,
-)
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-
-_logger = logging.getLogger(__name__)
-
-
-class NabuHelicalPrepareWeightsDoubleOW(
-    TomwerWithStackStack,
-    ewokstaskclass=NabuHelicalPrepareWeightsDouble,
-):
-    """
-    widget used to call the `nabu-helical-prepare-weights-double` application on a dedicated thread. It define weights map and double flat field.
-
-    :param parent: the parent widget
-    """
-
-    # note of this widget should be the one registered on the documentation
-    name = "helical prepate weights double"
-    id = "orangecontrib.tomwer.widgets.reconstruction.NabuHelicalPrepareWeightsDoubleOW.NabuHelicalPrepareWeightsDoubleOW"
-    description = "compute map of weights requested for nabu helical reconstruction"
-    icon = "icons/nabu_prepare_weights_double.svg"
-    priority = 199
-    keywords = [
-        "tomography",
-        "nabu",
-        "reconstruction",
-        "nabu-helical",
-        "helical",
-        "weights",
-        "prepare",
-    ]
-
-    want_main_area = True
-    want_control_area = False
-    resizing_enabled = True
-
-    _ewoks_default_inputs = Setting(
-        {
-            "data": None,
-            "transition_width": 50,
-            "processes_file": "",
-        }
-    )
-
-    sigScanReady = qt.Signal(TomwerScanBase)
-    "Signal emitted when a scan is ended"
-
-    TIMEOUT = 30
-
-    class Inputs:
-        data = Input(
-            name="data",
-            type=TomwerScanBase,
-            doc="one scan to be process",
-            default=True,
-            multiple=False,
-        )
-
-    class Outputs:
-        data = Output(name="data", type=TomwerScanBase, doc="one scan to be process")
-        future_tomo_obj = Output(
-            name="future_tomo_obj",
-            type=FutureTomwerObject,
-            doc="future object (process remotely)",
-        )
-
-    LOGGER = _logger
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.__scan = None
-
-        # gui definition
-        _layout = gui.vBox(self.mainArea, self.name).layout()
-        self.widget = HelicalPrepareWeightsDouble(parent=self)
-        _layout.addWidget(self.widget)
-
-        ## connect signal / slot
-        self.widget.sigConfigChanged.connect(self._updateSettings)
-
-        self.task_output_changed_callbacks.add(self._notify_state)
-
-        ## handle settings
-        self._loadSettings()
-        self.task_executor_queue.sigComputationStarted.connect(self._newTaskStarted)
-
-    def _updateSettings(self):
-        config = self.widget.getConfiguration()
-        for key in ("transition_width", "processes_file"):
-            self._ewoks_default_inputs[key] = config[key]  # pylint: disable=E1137
-
-    @property
-    def request_input(self):
-        return self.__request_input
-
-    @request_input.setter
-    def request_input(self, request):
-        self.__request_input = request
-
-    def get_task_inputs(self):
-        assert self.__scan is not None
-        return {
-            "data": self.__scan,
-            "transition_width": self.widget.getConfiguration()["transition_width"],
-            "processes_file": self.widget.getConfiguration()["processes_file"],
-        }
-
-    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
-        data = super().get_task_inputs().get("data", None)
-        if data is not None:
-            if not isinstance(data, HDF5TomoScan):
-                raise TypeError(
-                    f"data is expected to be an instance of HDF5TomoScan. {type(data)} are not handled"
-                )
-            self.add(data.path)
-
-    def _loadSettings(self):
-        self.widget.setConfiguration(self._ewoks_default_inputs)
-
-    def _newTaskStarted(self):
-        try:
-            task_executor = self.sender()
-            scan = task_executor.current_task.inputs.data
-            self.notify_on_going(scan)
-        except Exception:
-            pass
-
-    def _notify_state(self):
-        try:
-            task_executor = self.sender()
-            task_suceeded = task_executor.succeeded
-            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}")
-
-    @Inputs.data
-    def process_data(self, scan: Optional[TomwerScanBase]):
-        if scan is None:
-            return
-        else:
-            self.__scan = scan
-            self.notify_pending(scan=scan)
-            self.execute_ewoks_task()
-
-    def sizeHint(self) -> qt.QSize:
-        return qt.QSize(650, 60)
+# import logging
+
+# from orangewidget import gui
+# from orangewidget.settings import Setting
+# from orangewidget.widget import Input, Output
+# from orangecontrib.tomwer.orange.managedprocess import TomwerWithStackStack
+# from silx.gui import qt
+# from typing import Optional
+
+# from tomwer.core.futureobject import FutureTomwerObject
+# from tomwer.core.scan.scanbase import TomwerScanBase
+# from tomwer.gui.reconstruction.nabu.helical import HelicalPrepareWeightsDouble
+# from tomwer.core.process.reconstruction.nabu.helical import (
+#     NabuHelicalPrepareWeightsDouble,
+# )
+# from tomwer.core.scan.hdf5scan import HDF5TomoScan
+
+# _logger = logging.getLogger(__name__)
+
+
+# class NabuHelicalPrepareWeightsDoubleOW(
+#     TomwerWithStackStack,
+#     ewokstaskclass=NabuHelicalPrepareWeightsDouble,
+# ):
+#     """
+#     widget used to call the `nabu-helical-prepare-weights-double` application on a dedicated thread. It define weights map and double flat field.
+
+#     :param parent: the parent widget
+#     """
+
+#     # note of this widget should be the one registered on the documentation
+#     name = "helical prerate weights double"
+#     id = "orangecontrib.tomwer.widgets.reconstruction.NabuHelicalPrepareWeightsDoubleOW.NabuHelicalPrepareWeightsDoubleOW"
+#     description = "compute map of weights requested for nabu helical reconstruction"
+#     icon = "icons/nabu_prepare_weights_double.svg"
+#     priority = 199
+#     keywords = [
+#         "tomography",
+#         "nabu",
+#         "reconstruction",
+#         "nabu-helical",
+#         "helical",
+#         "weights",
+#         "prepare",
+#     ]
+
+#     want_main_area = True
+#     want_control_area = False
+#     resizing_enabled = True
+
+#     _ewoks_default_inputs = Setting(
+#         {
+#             "data": None,
+#             "transition_width": 50,
+#             "processes_file": "",
+#         }
+#     )
+
+#     sigScanReady = qt.Signal(TomwerScanBase)
+#     "Signal emitted when a scan is ended"
+
+#     TIMEOUT = 30
+
+#     class Inputs:
+#         data = Input(
+#             name="data",
+#             type=TomwerScanBase,
+#             doc="one scan to be process",
+#             default=True,
+#             multiple=False,
+#         )
+
+#     class Outputs:
+#         data = Output(name="data", type=TomwerScanBase, doc="one scan to be process")
+#         future_tomo_obj = Output(
+#             name="future_tomo_obj",
+#             type=FutureTomwerObject,
+#             doc="future object (process remotely)",
+#         )
+
+#     LOGGER = _logger
+
+#     def __init__(self, parent=None):
+#         super().__init__(parent)
+#         self.__scan = None
+
+#         # gui definition
+#         _layout = gui.vBox(self.mainArea, self.name).layout()
+#         self.widget = HelicalPrepareWeightsDouble(parent=self)
+#         _layout.addWidget(self.widget)
+
+#         ## connect signal / slot
+#         self.widget.sigConfigChanged.connect(self._updateSettings)
+
+#         self.task_output_changed_callbacks.add(self._notify_state)
+
+#         ## handle settings
+#         self._loadSettings()
+#         self.task_executor_queue.sigComputationStarted.connect(self._newTaskStarted)
+
+#     def _updateSettings(self):
+#         config = self.widget.getConfiguration()
+#         for key in ("transition_width", "processes_file"):
+#             self._ewoks_default_inputs[key] = config[key]  # pylint: disable=E1137
+
+#     @property
+#     def request_input(self):
+#         return self.__request_input
+
+#     @request_input.setter
+#     def request_input(self, request):
+#         self.__request_input = request
+
+#     def get_task_inputs(self):
+#         assert self.__scan is not None
+#         return {
+#             "data": self.__scan,
+#             "transition_width": self.widget.getConfiguration()["transition_width"],
+#             "processes_file": self.widget.getConfiguration()["processes_file"],
+#         }
+
+#     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
+#         data = super().get_task_inputs().get("data", None)
+#         if data is not None:
+#             if not isinstance(data, HDF5TomoScan):
+#                 raise TypeError(
+#                     f"data is expected to be an instance of HDF5TomoScan. {type(data)} are not handled"
+#                 )
+#             self.add(data.path)
+
+#     def _loadSettings(self):
+#         self.widget.setConfiguration(self._ewoks_default_inputs)
+
+#     def _newTaskStarted(self):
+#         try:
+#             task_executor = self.sender()
+#             scan = task_executor.current_task.inputs.data
+#             self.notify_on_going(scan)
+#         except Exception:
+#             pass
+
+#     def _notify_state(self):
+#         try:
+#             task_executor = self.sender()
+#             task_suceeded = task_executor.succeeded
+#             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}")
+
+#     @Inputs.data
+#     def process_data(self, scan: Optional[TomwerScanBase]):
+#         if scan is None:
+#             return
+#         else:
+#             self.__scan = scan
+#             self.notify_pending(scan=scan)
+#             self.execute_ewoks_task()
+
+#     def sizeHint(self) -> qt.QSize:
+#         return qt.QSize(650, 60)

tomwer/app/canvas_launcher/mainwindow.py

@@ -61,9 +61,7 @@ class MainWindow(_MainWindow):
     HELPDESK_URL = "https://requests.esrf.fr/plugins/servlet/desk/portal/41"
 
     def __init__(self, *args, **kwargs):
-        print("create window")
         super().__init__(*args, **kwargs)
-        print("end super")
         self.process_supervisor_dock = DockWidget(
             self.tr("object supervisor"),
             self,
@@ -71,7 +69,6 @@ class MainWindow(_MainWindow):
             allowedAreas=qt.Qt.BottomDockWidgetArea,
             visible=self.show_processes_manager_action.isChecked(),
         )
-        print("continue")
 
         self.process_supervisor_dock.setWidget(ProcessManagerWindow(parent=None))
         self.process_supervisor_dock.visibilityChanged[bool].connect(

tomwer/app/imagekeyeditor.py

@@ -85,6 +85,7 @@ def main(argv):
     options.scan_path = options.scan_path.rstrip(os.path.sep)
 
     widget = ImageKeyDialog(parent=None)
+    widget.setWindowFlags(qt.Qt.Window)
     widget.setScan(scan)
     widget.setWindowTitle("Image key editor")
     widget.setWindowIcon(icons.getQIcon("tomwer"))

tomwer/app/imagekeyupgrader.py

@@ -94,6 +94,8 @@ def main(argv):
     options.scan_path = options.scan_path.rstrip(os.path.sep)
 
     widget = ImageKeyUpgraderDialog(parent=None)
+    widget.setWindowFlags(qt.Qt.Window)
+
     widget.setScan(scan)
     widget.setWindowTitle("Image key upgrader")
     widget.setWindowIcon(icons.getQIcon("tomwer"))

tomwer/app/nxtomoeditor.py

@@ -83,6 +83,8 @@ def main(argv):
         return
 
     dialog = NXtomoEditorDialog()
+    dialog.setWindowFlags(qt.Qt.Window)
+
     dialog.setScan(scan)
     dialog.show()
     splash.finish(dialog)

tomwer/app/zstitching.py

@@ -257,6 +257,7 @@ def main(argv):
     timer.timeout.connect(lambda: None)
 
     window = MainWindow()
+    window.setWindowFlags(qt.Qt.Window)
 
     window.show()
     from sluurp.utils import has_sbatch_available

tomwer/core/process/reconstruction/nabu/nabucommon.py

@@ -327,6 +327,18 @@ class _NabuBaseReconstructor:
         else:
             raise ValueError(f"{self.target} is not recognized as a valid target")
 
+    @staticmethod
+    def _get_gpu_and_cpu_mem_fraction(config_to_dump: dict):
+        gpu_mem_fraction = config_to_dump.get("resources", {}).get(
+            "gpu_mem_fraction", config_to_dump.get("gpu_mem_fraction", 0.9)
+        )
+        assert gpu_mem_fraction <= 1
+        cpu_mem_fraction = config_to_dump.get("resources", {}).get(
+            "cpu_mem_fraction", config_to_dump.get("cpu_mem_fraction", 0.9)
+        )
+        assert cpu_mem_fraction <= 1
+        return gpu_mem_fraction, cpu_mem_fraction
+
     def _run_nabu_locally(
         self,
         conf_file: str,
@@ -346,8 +358,22 @@ class _NabuBaseReconstructor:
         """
         if not has_nabu:
             raise ImportError("Fail to import nabu")
+        assert isinstance(config_to_dump, dict)
+        gpu_mem_fraction, cpu_mem_fraction = self._get_gpu_and_cpu_mem_fraction(
+            config_to_dump
+        )
+
         command = " ".join(
-            ("python3", "-m", settings.NABU_FULL_FIELD_APP_PATH, conf_file)
+            (
+                "python3",
+                "-m",
+                settings.NABU_FULL_FIELD_APP_PATH,
+                conf_file,
+                "--gpu_mem_fraction",
+                str(gpu_mem_fraction),
+                "--cpu_mem_fraction",
+                str(cpu_mem_fraction),
+            )
         )
         _logger.info(f'call nabu from "{command}"')
 
@@ -422,13 +448,21 @@ class _NabuBaseReconstructor:
         project_name = project_name.replace(" ", "_")
         cluster_config["job_name"] = project_name
 
+        # extract gpu_mem_fraction and cpu_mem_fraction
+        assert isinstance(config_to_dump, dict)
+        gpu_mem_fraction, cpu_mem_fraction = self._get_gpu_and_cpu_mem_fraction(
+            config_to_dump
+        )
+
         # submit job
         script_name = get_slurm_script_name(prefix="nabu")
         # for now force job name
         cluster_config["job_name"] = f"tomwer-nabu {conf_file}"
         job = SBatchScriptJob(
             slurm_config=cluster_config,
-            script=(f"python3 -m {settings.NABU_FULL_FIELD_APP_PATH} {conf_file}",),
+            script=(
+                f"python3 -m {settings.NABU_FULL_FIELD_APP_PATH} {conf_file} --gpu_mem_fraction {gpu_mem_fraction} --cpu_mem_fraction {cpu_mem_fraction}",
+            ),
             script_path=os.path.join(self.scan.path, "slurm_scripts", script_name),
             clean_script=False,
             working_directory=self.scan.working_directory,
@@ -455,10 +489,12 @@ class _NabuBaseReconstructor:
         """Return a tuple a potential callback to be launch once the future is done"""
         return tuple()
 
-    def _treateOutputSliceConfig(self, config):
+    def _treateOutputSliceConfig(self, config) -> tuple:
         """
         - add or overwrite some parameters of the dictionary
         - create the output directory if does not exist
+
+        :return: (config: dict, nabu_cfg_folder: str)
         """
         # handle phase
         pag = False
@@ -492,16 +528,26 @@ class _NabuBaseReconstructor:
             location = config["output"].get("location", None)
             if location not in ("", None):
                 location = format_output_location(location, scan=self.scan)
-                # if user specify the location
-                if not os.path.isdir(config["output"]["location"]):
-                    os.makedirs(location)
+                location_cfg_files = location
             else:
                 # otherwise default location will be the data root level
                 location = self.scan.path
+                location_cfg_files = location
+                # TODO: if is a single file - append prefix
+                if config["output"].get("file_format") in (
+                    NabuOutputFileFormat.EDF.value,
+                    NabuOutputFileFormat.TIFF.value,
+                    NabuOutputFileFormat.JP2K.value,
+                ):  # if user specify the location
+                    location = "/".join([location, _file_name])
+
             # add reconstruction path to the list. scan `reconstruction_paths` register all the existing path where
             # reconstruction are saved in order to be able to browse them all
             self.scan.add_reconstruction_path(location)
             config["output"]["location"] = location
+        else:
+            # don't think this could ever happen
+            location_cfg_files = self.scan.path
         # handle preproc
         if "preproc" not in config:
             config["preproc"] = {}
@@ -514,14 +560,14 @@ class _NabuBaseReconstructor:
 
         extra_infos = self.scan.intensity_normalization.get_extra_infos()
 
-        nabu_cfg_folders = os.path.join(
-            config["output"]["location"], settings.NABU_CFG_FILE_FOLDER
+        nabu_cfg_folder = os.path.join(
+            location_cfg_files, settings.NABU_CFG_FILE_FOLDER
         )
-        os.makedirs(nabu_cfg_folders, exist_ok=True)
+        os.makedirs(nabu_cfg_folder, exist_ok=True)
 
         # configuration file and nabu_tomwer_serving_hatch must be in the same folder
         serving_hatch_file = os.path.join(
-            nabu_cfg_folders, settings.NABU_TOMWER_SERVING_HATCH
+            nabu_cfg_folder, settings.NABU_TOMWER_SERVING_HATCH
         )
 
         source = extra_infos.get("source", INormSource.NONE)
@@ -576,8 +622,7 @@ class _NabuBaseReconstructor:
                 )
         else:
             raise NotImplementedError(f"source type {source.value} is not handled")
-
-        return config
+        return config, nabu_cfg_folder
 
     def _get_file_basename_reconstruction(self, pag, db, ctf):
         """return created file base name"""

tomwer/core/process/reconstruction/nabu/nabuscores.py

@@ -223,6 +223,8 @@ class _Reconstructor(_NabuBaseReconstructor):
             if self._cancelled:
                 break
             config, conf_file = self.preprocess_config(deepcopy(config), var_value)
+            print("conf file is", conf_file)
+            print("confif output is", config.get("output"))
 
             # add some tomwer metadata and save the configuration
             # note: for now the section is ignored by nabu but shouldn't stay that way
@@ -336,8 +338,7 @@ class _Reconstructor(_NabuBaseReconstructor):
             config["output"]["location"],
             nabu_settings.NABU_CFG_FILE_FOLDER,
         )
-        if not os.path.exists(cfg_folder):
-            os.makedirs(cfg_folder)
+        os.makedirs(cfg_folder, exist_ok=True)
 
         conf_file = os.path.join(
             cfg_folder, file_prefix + nabu_settings.NABU_CONFIG_FILE_EXTENSION

tomwer/core/process/reconstruction/nabu/nabuslices.py

@@ -716,17 +716,15 @@ class SingleSliceRunner(_NabuBaseReconstructor):
             "steps_file": steps_file,
         }
 
-        config = self._treateOutputSliceConfig(config)
+        config, cfg_folder = self._treateOutputSliceConfig(config)
         # the policy is to save nabu .cfg file at the same location as the
         # force overwrite results
         if self.slice_index is not None:
             config["reconstruction"]["start_z"] = self.slice_index
             config["reconstruction"]["end_z"] = self.slice_index
-        cfg_folder = os.path.join(
-            config["output"]["location"], nabu_settings.NABU_CFG_FILE_FOLDER
-        )
-        if not os.path.exists(cfg_folder):
-            os.makedirs(cfg_folder)
+
+        if self.slice_index is not None:
+            os.makedirs(config["output"]["location"], exist_ok=True)
 
         name = (
             config["output"]["file_prefix"] + nabu_settings.NABU_CONFIG_FILE_EXTENSION
@@ -828,7 +826,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 return "_".join(
                     (
                         basename + "slice_pag",
-                        str(slice_index).zfill(4),
+                        str(slice_index).zfill(6),
                         "db" + str(db).zfill(4),
                     )
                 )
@@ -836,12 +834,12 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 return "_".join(
                     (
                         basename + "slice_ctf",
-                        str(slice_index).zfill(4),
+                        str(slice_index).zfill(6),
                         "db" + str(db).zfill(4),
                     )
                 )
             else:
-                return "_".join((basename + "slice", str(slice_index).zfill(4)))
+                return "_".join((basename + "slice", str(slice_index).zfill(6)))
 
     @docstring(_NabuBaseReconstructor)
     def _get_file_basename_reconstruction(self, pag, db, ctf):