tomwer 1.4.3__tar.gz → 1.4.5__tar.gz

{tomwer-1.4.3/src/tomwer.egg-info → tomwer-1.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tomwer
-Version: 1.4.3
+Version: 1.4.5
 Summary: "tomography workflow tools"
 Home-page: https://gitlab.esrf.fr/tomotools/tomwer
 Author: Henri Payno, Pierre Paleo, Pierre-Olivier Autran, Jérôme Lesaint, Alessandro Mirone

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer/app/stitching/common.py

@@ -181,21 +181,8 @@ class _StitcherThread(qt.QThread):
             },
         )
 
-        if self._cluster_config in (None, {}):
-            self._runLocally(task)
-        else:
-            self._runRemotely(task)
-
-    def _runLocally(self, task):
-        task.run()
-
-    def _runRemotely(self, task):
         task.run()
-        # wait for processing to be finished
-        for future in task.outputs.future_tomo_obj.futures:
-            future.result()
-        # note: there is also a callback to aggregate result once all are finished.
-        # so at this stage the final "nxtomo" or "volume" might not exists yet
+        print("stitching finished")
 
 
 class MainWindow(qt.QDialog):

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer/core/process/reconstruction/nabu/nabucommon.py

@@ -15,6 +15,8 @@ import sys
 import numpy
 from silx.io.url import DataUrl
 from silx.io.utils import open as open_hdf5
+from silx.gui.utils import concurrent
+
 from sluurp.executor import submit as submit_to_slurm_cluster
 from sluurp.job import SBatchScriptJob
 from tomoscan.io import HDF5File
@@ -41,6 +43,8 @@ from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils.slurm import get_slurm_script_name, is_slurm_available
 from tomwer.core.volume.volumefactory import VolumeFactory
+from tomwer.core.resourcemanager import HDF5VolumeManager
+from tomwer.core.volume.hdf5volume import HDF5VolumeIdentifier
 
 from . import settings, utils
 
@@ -279,25 +283,43 @@ class _NabuBaseReconstructor:
                 success=True,
                 config=config_to_dump,
             )
-        elif self.target is Target.LOCAL:
-            _logger.info(f"run {info} for {self.scan} with {config_to_dump}")
-            return self._run_nabu_locally(
-                conf_file=config_file,
-                file_format=file_format,
-                config_to_dump=config_to_dump,
-                axis=config_to_dump["reconstruction"].get("slice_plane", "XY"),
-            )
-        elif self.target is Target.SLURM:
-            _logger.info(
-                f"run {info} on slurm for {self.scan.path} with {config_to_dump}"
-            )
-            return self._run_nabu_on_slurm(
-                conf_file=config_file,
-                config_to_dump=config_to_dump,
-                cluster_config=self.cluster_config.to_dict(),
-                process_name=process_name,
-                info=info,
-            )
+        elif self.target in (Target.LOCAL, Target.SLURM):
+            axis = config_to_dump["reconstruction"].get("slice_plane", "XY")
+            if file_format in ("hdf5", "h5", "hdf"):
+                vol_identifiers = utils.get_recons_volume_identifier(
+                    file_prefix=config_to_dump["output"]["file_prefix"],
+                    location=config_to_dump["output"]["location"],
+                    slice_index=None,
+                    scan=self.scan,
+                    file_format=file_format,
+                    axis=axis,
+                )
+                # release potential resource lockers (like the HDF5 volume viewer)
+                for vol_identifier in vol_identifiers:
+                    if isinstance(vol_identifier, HDF5VolumeIdentifier):
+                        concurrent.submitToQtMainThread(
+                            HDF5VolumeManager.release_resource,
+                            vol_identifier.file_path,
+                        )
+            if self.target is Target.LOCAL:
+                _logger.info(f"run {info} for {self.scan} with {config_to_dump}")
+                return self._run_nabu_locally(
+                    conf_file=config_file,
+                    file_format=file_format,
+                    config_to_dump=config_to_dump,
+                    axis=axis,
+                )
+            elif self.target is Target.SLURM:
+                _logger.info(
+                    f"run {info} on slurm for {self.scan.path} with {config_to_dump}"
+                )
+                return self._run_nabu_on_slurm(
+                    conf_file=config_file,
+                    config_to_dump=config_to_dump,
+                    cluster_config=self.cluster_config.to_dict(),
+                    process_name=process_name,
+                    info=info,
+                )
         else:
             raise ValueError(f"{self.target} is not recognized as a valid target")
 
@@ -362,7 +384,7 @@ class _NabuBaseReconstructor:
             self._process.kill()
             outs, errs = self._process.communicate()
 
-        recons_urls = utils.get_recons_volume_identifier(
+        recons_vol_identifiers = utils.get_recons_volume_identifier(
             file_prefix=config_to_dump["output"]["file_prefix"],
             location=config_to_dump["output"]["location"],
             slice_index=None,
@@ -372,7 +394,7 @@ class _NabuBaseReconstructor:
         )
         return ResultsLocalRun(
             success=not nabu_std_err_has_error(errs),
-            results_identifiers=recons_urls,
+            results_identifiers=recons_vol_identifiers,
             std_out=outs,
             std_err=errs,
             config=config_to_dump,  # config_slices,

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer/core/process/reconstruction/nabu/utils.py

@@ -12,6 +12,7 @@ from nabu.pipeline.fullfield.nabu_config import (
 )
 from silx.utils.enum import Enum as _Enum
 
+from tomoscan.identifier import VolumeIdentifier
 import tomwer.version
 from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
 from tomwer.core.scan.edfscan import EDFTomoScan
@@ -100,7 +101,7 @@ def get_recons_volume_identifier(
     scan: TomwerScanBase,
     slice_index: int | None,
     axis: NabuPlane,
-) -> tuple:
+) -> tuple[VolumeIdentifier]:
     """
     return tuple of DataUrl for existings slices
     """
@@ -160,19 +161,6 @@ def get_recons_volume_identifier(
             ),
         )
 
-    # case of the multitiff. Not handled by tomwer
-    # elif file_format == "tiff":
-    #     # for single frame tiff nabu uses another convention by saving it 'directly'.
-    #     volumes = (
-    #         MultiTIFFVolume(
-    #             file_path=os.path.join(
-    #                 location,
-    #                 file_prefix,
-    #                 ".".join([file_prefix, file_format]),
-    #             ),
-    #         ),
-    #     )
-
     else:
         raise ValueError(f"file format not managed: {file_format}")
 

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer/core/process/stitching/nabustitcher.py

@@ -26,7 +26,6 @@ from processview.core.superviseprocess import SuperviseProcess
 from tomwer.core.process.task import Task
 from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanfactory import ScanFactory
-from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.volume.volumefactory import VolumeFactory
 
 
@@ -135,32 +134,24 @@ class StitcherTask(
                 stitching_config=config,
                 progress_bars=slurm_job_progress_bars,
             )
-            for future in futures.values():
-                # TODO: do we ned to make sure the processing is not finished yet ?
-                future.add_done_callback(data_aggregation.onePartFinished)
+            # will wait and provide feedback until the stitching is completed.
+            data_aggregation.process()
 
             if config.stitching_type is StitchingType.Z_PREPROC:
                 output_nx_tomo_file = config.output_file_path
                 output_nx_tomo_entry = config.output_data_path
-                tomwer_scan = NXtomoScan(
+                self.outputs.data = NXtomoScan(
                     scan=output_nx_tomo_file, entry=output_nx_tomo_entry
                 )
-                self.outputs.future_tomo_obj = FutureTomwerObject(
-                    tomo_obj=tomwer_scan,
-                    futures=tuple(futures.values()),
-                )
-                self.outputs.data = None
+                self.outputs.future_tomo_obj = None
                 self.outputs.volume = None
 
             elif config.stitching_type is StitchingType.Z_POSTPROC:
                 tomwer_volume = VolumeFactory.create_tomo_object_from_identifier(
                     config.output_volume.get_identifier().to_str()
                 )
-                self.outputs.future_tomo_obj = FutureTomwerObject(
-                    tomo_obj=tomwer_volume,
-                    futures=tuple(futures.values()),
-                )
-                self.outputs.volume = None
+                self.outputs.future_tomo_obj = None
+                self.outputs.volume = tomwer_volume
                 self.outputs.data = None
 
 
@@ -171,7 +162,7 @@ class StitchingPostProcAggregation(_StitchingPostProcAggregation):
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self._n_finished = 0
+        print("creates StitchingPostProcAggregation")
 
         if isinstance(self.stitching_config, dict):
             stitching_type = StitchingType.from_value(
@@ -192,10 +183,6 @@ class StitchingPostProcAggregation(_StitchingPostProcAggregation):
                 f"stitching_config is expected to be an instance of {StitchingConfiguration}. {type(self.stitching_config)} provided instead"
             )
 
-    def onePartFinished(self, *args, **kwargs):
-        self._n_finished += 1
-        # note: for now we only consider the user of the futures.
-        # if users want to only run post-processing agregation then they will use the nabu CLI for it.
-        if self._n_finished == len(self._futures):
-            _logger.info("All slurm job finished. Will aggregate results")
-            self.process()
+    def process(self):
+        super().process()
+        _logger.info("Stitching finished.")

tomwer-1.4.5/src/tomwer/core/resourcemanager.py

@@ -0,0 +1,33 @@
+class BaseResourceObserver:
+    """base class of the resource observer"""
+
+    def release_resource(self, resource):
+        raise NotImplementedError("Base class")
+
+
+class _DummyResourceManager:
+    """
+    Simple resource manager. It holds a set of observer tha must release a resource when requested
+    Observers must implement the 'BaseResourceObserver'
+    """
+
+    def __init__(self):
+        self._observers = set()
+
+    def register(self, observer):
+        """Register a process to be notified when the resource should be released."""
+        if observer not in self._observers:
+            self._observers.add(observer)
+
+    def unregister(self, observer):
+        """Unregister a process so it won't be notified anymore."""
+        if observer in self._observers:
+            self._observers.remove(observer)
+
+    def release_resource(self, resource: str):
+        """Force all observer to release the given resource"""
+        for observer in self._observers:
+            observer.release_resource(resource)
+
+
+HDF5VolumeManager = _DummyResourceManager()

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer/gui/reconstruction/axis/ControlWidget.py

@@ -211,7 +211,7 @@ class _PositionInfoWidget(qt.QWidget):
         else:
             value = float(self._relativePositionQLE.text())
             # make sure we only emit the signal if the value changed (and when the Qline has been edited).
-            if self._axis_params.relative_cor_value is None or (
+            if isinstance(self._axis_params.relative_cor_value, (type(None), str)) or (
                 self._axis_params is not None
                 and not numpy.isclose(
                     value, self._axis_params.relative_cor_value, atol=1e-3

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer/gui/reconstruction/nabu/nabuconfig/phase.py

@@ -95,6 +95,7 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
         self._unsharpOpts.setDiscourageUnsharpMask(
             self.getMethod() is _NabuPhaseMethod.NONE
         )
+        self._unsharpOpts._updateUnsharpMaskWarning()
         self.sigConfChanged.emit("method")
 
     def _signalConfChanged(self, param):

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer/gui/visualization/volumeviewer.py

@@ -6,6 +6,8 @@ import h5py
 
 import numpy
 import numpy.lib.npyio
+
+import os
 import silx
 from silx.gui import qt
 from silx.gui.colors import Colormap
@@ -18,6 +20,7 @@ from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.visualization.reconstructionparameters import ReconstructionParameters
 from tomwer.core.volume.hdf5volume import HDF5Volume
+from tomwer.core.resourcemanager import BaseResourceObserver, HDF5VolumeManager
 from tomoscan.identifier import VolumeIdentifier
 
 from silx.gui.widgets.WaitingOverlay import WaitingOverlay
@@ -215,9 +218,9 @@ class _TomoApplicationContext(DataViewHooks):
         return self.__defaultColormapDialog
 
 
-class VolumeViewer(qt.QMainWindow):
+class VolumeViewer(qt.QMainWindow, BaseResourceObserver):
     def __init__(self, parent):
-        qt.QMainWindow.__init__(self, parent)
+        super().__init__(parent)
 
         self._volume_loaded_in_background = (None, None)
         # store the volume loaded in the background and the thread used for it as (volume_identifier, thread)
@@ -259,6 +262,8 @@ class VolumeViewer(qt.QMainWindow):
         loading data on the fly and avoid loading everything into memory for
         hdf5."""
         self.__last_mode = None
+        # register the viewer as observer of the HDF5 volume (handle resource conflict)
+        HDF5VolumeManager.register(self)
 
     def _close_h5_file(self):
         if self._h5_file is not None:
@@ -266,9 +271,21 @@ class VolumeViewer(qt.QMainWindow):
         self._h5_file = None
 
     def close(self):
+        HDF5VolumeManager.unregister(self)
         self._close_h5_file()
         super().close()
 
+    def release_resource(self, resource: str):
+        if self._h5_file is not None and resource in (
+            self._h5_file.filename,
+            os.path.abspath(self._h5_file.filename),
+        ):
+            _logger.warning(
+                f"{resource} about to be overwrite. Closing resource and cleaning plot."
+            )
+            self._close_h5_file()
+            self.clear()
+
     def setScan(self, scan):
         self.clear()
         if scan is None:
@@ -276,7 +293,6 @@ class VolumeViewer(qt.QMainWindow):
 
         elif len(scan.latest_vol_reconstructions) == 0:
             _logger.warning(f"No reconstructed volume for {scan}")
-            self.clear()
             self._infoWidget.setScan(scan)
         else:
             self._set_volumes(volumes=scan.latest_vol_reconstructions)

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer/version.py

@@ -77,7 +77,7 @@ RELEASE_LEVEL_VALUE = {
 
 MAJOR = 1
 MINOR = 4
-MICRO = 3
+MICRO = 5
 RELEV = "final"  # <16
 SERIAL = 0  # <16
 

{tomwer-1.4.3 → tomwer-1.4.5/src/tomwer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tomwer
-Version: 1.4.3
+Version: 1.4.5
 Summary: "tomography workflow tools"
 Home-page: https://gitlab.esrf.fr/tomotools/tomwer
 Author: Henri Payno, Pierre Paleo, Pierre-Olivier Autran, Jérôme Lesaint, Alessandro Mirone

{tomwer-1.4.3 → tomwer-1.4.5}/src/tomwer.egg-info/SOURCES.txt

@@ -268,6 +268,7 @@ src/tomwer/app/stitching/__init__.py
 src/tomwer/app/stitching/common.py
 src/tomwer/core/__init__.py
 src/tomwer/core/futureobject.py
+src/tomwer/core/resourcemanager.py
 src/tomwer/core/settings.py
 src/tomwer/core/signal.py
 src/tomwer/core/tomwer_object.py