tomwer 2.0.0.dev5__tar.gz → 2.0.0.dev7__tar.gz

{tomwer-2.0.0.dev5/src/tomwer.egg-info → tomwer-2.0.0.dev7}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: tomwer
-Version: 2.0.0.dev5
+Version: 2.0.0.dev7
 Summary: Tomography workflow tools
-Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>
+Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 License: MIT
 Project-URL: Homepage, https://gitlab.esrf.fr/tomotools/tomwer
 Project-URL: Documentation, https://tomotools.gitlab-pages.esrf.fr/tomwer/
@@ -43,7 +43,7 @@ Provides-Extra: full-base
 Requires-Dist: orange-canvas-core; extra == "full-base"
 Requires-Dist: orange-widget-base; extra == "full-base"
 Requires-Dist: ewokscore; extra == "full-base"
-Requires-Dist: ewoksorange>=3.3.0; extra == "full-base"
+Requires-Dist: ewoksorange<5.0,>=3.3.0; extra == "full-base"
 Requires-Dist: fabio; extra == "full-base"
 Requires-Dist: h5py>=3; extra == "full-base"
 Requires-Dist: lxml; extra == "full-base"
@@ -76,7 +76,7 @@ Requires-Dist: tomwer[full_no_qt]; extra == "full"
 Requires-Dist: PyQt6; extra == "full"
 Provides-Extra: doc
 Requires-Dist: tomwer[full_no_cuda]; extra == "doc"
-Requires-Dist: Sphinx>=4.0.0; extra == "doc"
+Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: nbsphinx; extra == "doc"
 Requires-Dist: pandoc; extra == "doc"
 Requires-Dist: jupyterlab; extra == "doc"

{tomwer-2.0.0.dev5 → tomwer-2.0.0.dev7}/pyproject.toml

@@ -6,7 +6,6 @@ authors = [
     { name = "Pierre Paleo", email = "pierre.paleo@esrf.fr" },
     { name = "Pierre-Olivier Autran", email = "pierre-olivier.autran@esrf.fr" },
     { name = "Jérôme Lesaint", email = "jerome.lesaint@esrf.fr" },
-    { name = "Alessandro Mirone", email = "mirone@esrf.fr" }
 ]
 description = "Tomography workflow tools"
 readme = { file = "README.rst", content-type = "text/x-rst" }
@@ -49,7 +48,7 @@ full_base = [
     "orange-canvas-core",
     "orange-widget-base",
     "ewokscore",
-    "ewoksorange>=3.3.0",
+    "ewoksorange>=3.3.0,<5.0",
     "fabio",
     "h5py>=3",
     "lxml",
@@ -86,7 +85,7 @@ full = [
 ]
 doc = [
     "tomwer[full_no_cuda]",
-    "Sphinx>=4.0.0",
+    "sphinx",
     "nbsphinx",
     "pandoc",
     "jupyterlab",

{tomwer-2.0.0.dev5 → tomwer-2.0.0.dev7}/src/orangecontrib/tomwer/widgets/reconstruction/CastNabuVolumeOW.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import logging
+
 from orangewidget import gui
+from orangewidget.settings import Setting
 from orangewidget.widget import Input
 
 from tomwer.models.cluster.slurm_cluster import SlurmClusterConfiguration
@@ -17,6 +20,8 @@ from orangecontrib.tomwer.orange.task_widgets.TomwerWidgetWithStack import (
 from orangecontrib.tomwer.orange.ewoks_compatibility import unpack_variable
 from processview.core.manager import DatasetState, ProcessManager
 
+_logger = logging.getLogger(__name__)
+
 
 class CastNabuVolumeOW(
     TomwerWidgetWithStack,
@@ -69,6 +74,8 @@ class CastNabuVolumeOW(
     )
     # Hide input defined by the GUI
 
+    _interactive_mode = Setting(False)
+
     class Inputs:
         data = Input(
             name="data",
@@ -103,16 +110,27 @@ class CastNabuVolumeOW(
         self._layout.addWidget(self._window)
 
         # load default configuration saved
-        self.setConfiguration(
-            filter_missing_data(
-                self.get_default_input_values("cast_volume_params") or {}
-            )
-        )
+        self.setConfiguration(filter_missing_data(self.get_default_input_values()))
         # Store process id to provide task / dataset state
         self.set_dynamic_input("process_id", self.process_id)
 
+        self._pending_data = None
+        """Store a scan arriving"""
+        self._pending_volume = None
+        """Store a volume arriving"""
+
+        self._last_data = None
+        """dataset currently processed"""
+        self._last_volume = None
+        """volume currently processed"""
+
+        # apply saved interactive mode
+        self._window.setInteractive(self._interactive_mode)
+
         # connect signal / slot
         self._window.sigConfigChanged.connect(self._updateConfig)
+        self._window.sigInteractiveModeChanged.connect(self._onInteractiveModeChanged)
+        self._window.sigProcessRequested.connect(self._onProcessRequested)
 
     @Inputs.data
     def process_data(self, data: TomwerScanBase | None, signal_id=None):
@@ -142,6 +160,8 @@ class CastNabuVolumeOW(
     def _process(self, data: TomwerScanBase | None, volume: TomwerVolumeBase | None):
         if data is None and volume is None:
             return
+        self._last_data = data
+        self._last_volume = volume
         # check types
         if data is not None and not isinstance(data, TomwerScanBase):
             raise TypeError(
@@ -153,15 +173,28 @@ class CastNabuVolumeOW(
             )
         if data is None and volume is None:
             raise ValueError("The scan of the volume should be given. Not both")
-        self.set_dynamic_input("volume", volume)
-        self.set_dynamic_input("data", data)
 
-        ProcessManager().notify_dataset_state(
-            dataset=data or volume,
-            process=self,
-            state=DatasetState.PENDING,
-        )
-        self.execute_ewoks_task()
+        if self._window.isInteractive():
+            # handling when in interactive mode
+            self._pending_data = data
+            self._pending_volume = volume
+            if volume is not None:
+                self._window.setVolume(volume)
+            ProcessManager().notify_dataset_state(
+                dataset=data or volume,
+                process=self,
+                state=DatasetState.PENDING,
+            )
+        else:
+            # handling when in automatic mode
+            self.set_dynamic_input("volume", volume)
+            self.set_dynamic_input("data", data)
+            ProcessManager().notify_dataset_state(
+                dataset=data or volume,
+                process=self,
+                state=DatasetState.PENDING,
+            )
+            self.execute_ewoks_task()
 
     def reprocess(self, dataset):
         if isinstance(dataset, TomwerScanBase):
@@ -171,6 +204,27 @@ class CastNabuVolumeOW(
         else:
             raise TypeError("dataset is expected to be an instance of ''")
 
+    def _onInteractiveModeChanged(self, interactive: bool) -> None:
+        self._interactive_mode = interactive
+        if interactive and self._last_volume is not None:
+            # switching from auto → interactive: load histogram and preview for
+            # the volume that was last processed in auto mode
+            self._pending_data = self._last_data
+            self._pending_volume = self._last_volume
+            self._window.setVolume(self._last_volume)
+
+    def _onProcessRequested(self) -> None:
+        if self._pending_data is None and self._pending_volume is None:
+            return
+        self.set_dynamic_input("volume", self._pending_volume)
+        self.set_dynamic_input("data", self._pending_data)
+        ProcessManager().notify_dataset_state(
+            dataset=self._pending_data or self._pending_volume,
+            process=self,
+            state=DatasetState.PENDING,
+        )
+        self.execute_ewoks_task()
+
     def getConfiguration(self) -> dict:
         return self._window.getConfiguration()
 
@@ -180,9 +234,14 @@ class CastNabuVolumeOW(
 
     def _updateConfig(self):
         configuration = self.getConfiguration()
-        for key in configuration.keys():
-            assert key in CastVolumeTask.input_model().model_fields.keys()
-            self.set_default_input(key, configuration[key])
+        valid_keys = CastVolumeTask.input_model().model_fields.keys()
+        for key, value in configuration.items():
+            if key not in valid_keys:
+                _logger.warning(
+                    "cast-volume: ignoring unknown configuration key %r", key
+                )
+                continue
+            self.set_default_input(key, value)
 
     def handleNewSignals(self) -> None:
         """

{tomwer-2.0.0.dev5 → tomwer-2.0.0.dev7}/src/orangecontrib/tomwer/widgets/reconstruction/CoROW.py

@@ -24,23 +24,15 @@ from tomwer.core.reconstruction.cor.mode import CoRMethod
 from tomwer.core.reconstruction.params_cache import (
     save_reconstruction_parameters_to_cache,
 )
+from tomwer.models.reconstruction.cor import CoRParams
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.reconstruction.cor import CoRMainWindow
-from tomwer.gui.reconstruction.cor.QCoRParams import QCoRParams as _QCoRParams
 from tomwer.synctools.stacks.reconstruction.cor import CoRProcessStack
 
 logger = logging.getLogger(__name__)
 
 
 class CoROW(SuperviseOW):
-    """
-    Widget used to defined the center of rotation (CoR) position to be used for a
-    reconstruction.
-
-    :param _connect_handler: True if we want to store the modifications
-                      on the setting. Need for unit test since
-                      keep alive qt widgets.
-    """
 
     name = "center of rotation finder"
     id = "orange.widgets.tomwer.axis"
@@ -90,43 +82,20 @@ class CoROW(SuperviseOW):
     class Outputs:
         data = Output(name="data", type=TomwerScanBase, doc="one scan to be process")
 
-    def __init__(self, parent=None, cor_params: _QCoRParams | None = None):
-        """
-
-        :param parent: QWidget parent or None
-        :param _connect_handler: used for CI, because if connected fails CI
-        :param cor_params: reconstruction parameters
-        """
+    def __init__(self, parent=None):
         super().__init__(parent)
-        if cor_params is not None:
-            if not isinstance(cor_params, _QCoRParams):
-                raise TypeError(
-                    f"cor_params should be an instance of QAxisRP. Not {type(cor_params)}"
-                )
-        self._cor_params = cor_params or _QCoRParams()
 
         # handle settings
-        #  axis params settings
-        cor_params_settings = self._ewoks_default_inputs.get(
-            ParametersKeys.COR_PARAMS_KEY, None
+        cor_params_dict = self._ewoks_default_inputs.get(
+            ParametersKeys.COR_PARAMS_KEY, CoRParams().model_dump()
         )
-        if cor_params_settings not in (None, dict()):
-            try:
-                self._cor_params.load_from_dict(cor_params_settings)
-            except Exception as e:
-                logger.error(f"fail to load reconstruction settings: {e}")
+        self._cor_params = CoRParams(**(cor_params_dict or CoRParams().model_dump()))
 
         #  gui settings
         gui_settings = self._ewoks_default_inputs.get("gui", {})
         if gui_settings is None:
             gui_settings = {}
 
-        original_mode = self._cor_params.mode
-        if original_mode is CoRMethod.manual:
-            original_cor = self._cor_params.relative_cor_value
-        else:
-            original_cor = None
-
         self.__lastAxisProcessParamsCache = None
         # used to memorize the last (reconstruction parameters, scan)
         self.__scan = None
@@ -135,14 +104,17 @@ class CoROW(SuperviseOW):
             cor_params=self._cor_params, process_id=self.process_id
         )
 
-        self._widget = CoRMainWindow(parent=self, cor_params=self._cor_params)
+        self._widget = CoRMainWindow(parent=self)
 
         self._layout = gui.vBox(self.mainArea, self.name).layout()
         self._layout.setContentsMargins(0, 0, 0, 0)
 
         self._layout.addWidget(self._widget)
 
-        # load settings
+        # push saved params into the GUI (handles manual/read mode restoration internally)
+        self._widget.setConfiguration(self._cor_params.model_dump())
+
+        # load gui settings
         try:
             if "mode_is_lock" in gui_settings:
                 mode_lock = gui_settings["mode_is_lock"]
@@ -172,37 +144,7 @@ class CoROW(SuperviseOW):
         self._processingStack.sigComputationStarted.connect(self._startProcessing)
         self._processingStack.sigComputationEnded.connect(self._scanProcessed)
 
-        self._cor_params.sigChanged.connect(self._updateSettingsVals)
-        self._widget._corWidget._settingsWidget._mainWidget._calculationWidget.sigUpdateXRotAxisPixelPosOnNewScan.connect(
-            self._updateSettingsVals
-        )
-        self._widget.sigAxisEditionLocked.connect(self._updateSettingsVals)
-        self._widget.sigModeChanged.connect(self._updateSettingsVals)
-        self._widget.sigLockModeChanged.connect(self._updateSettingsVals)
-
-        self._widget._corWidget._settingsWidget._mainWidget._calculationWidget._estimatedCorWidget.sigValueChanged.connect(
-            self._updateSettingsVals
-        )
-
-        # handle special case of the manual mode
-        # force axis to manual because not handled by the widget setup directly
-        if original_mode in (
-            CoRMethod.manual,
-            CoRMethod.read,
-        ):
-            self._cor_params.mode = original_mode
-            if original_cor is not None:
-                self._cor_params.set_relative_value(original_cor)
-
-            self.setMode(original_mode)
-            # force gui update
-            self._widget.sigModeChanged.emit("manual")
-            # hard fix, but this widget has to be redone and rework anyway
-            self._widget._corWidget._settingsWidget._mainWidget._calculationWidget._modeChanged()
-            if original_cor is not None:
-                self._widget._controlWidget._positionInfo.setPosition(
-                    relative_cor=original_cor, abs_cor=None
-                )
+        self._widget.sigConfigChanged.connect(self._updateSettingsVals)
 
     def _scanProcessed(self, scan, future_tomo_obj):
         assert isinstance(scan, TomwerScanBase)
@@ -240,8 +182,9 @@ class CoROW(SuperviseOW):
             self.show()
 
     def _processing_to_come_hash(self):
-        dict_for_cache = self._cor_params.to_dict().copy()
-        dict_for_cache.pop("POSITION_VALUE")
+        dict_for_cache = self.getConfiguration().copy()
+        dict_for_cache.pop("relative_cor_value", None)
+        dict_for_cache.pop("absolute_cor_value", None)
         return (
             dict_for_cache,
             str(self.__scan),
@@ -254,7 +197,7 @@ class CoROW(SuperviseOW):
             return
 
         if self.isValueLock():
-            cor = self._cor_params.relative_cor_value
+            cor = self.getConfiguration()["relative_cor_value"]
             save_reconstruction_parameters_to_cache(scan=scan)
         else:
             cor = None
@@ -272,7 +215,7 @@ class CoROW(SuperviseOW):
         self._processingStack.add(
             data=scan,
             configuration={
-                ParametersKeys.COR_PARAMS_KEY: self._cor_params.to_dict(),
+                ParametersKeys.COR_PARAMS_KEY: self.getConfiguration(),
                 "relative_cor_value": cor,
             },
             callback=callback,
@@ -284,7 +227,7 @@ class CoROW(SuperviseOW):
         """
         if self.__scan:
             if self.getMode() is CoRMethod.manual:
-                # when value is set from manual mode we need to retrieve it from the GUI `_axis_param`. Else it has already been set
+                # when value is set from manual mode we need to retrieve it from the GUI. Else it has already been set
                 # to the scan `_cor_params`
                 if (
                     self.__scan._cor_params.frame_width is None
@@ -292,9 +235,8 @@ class CoROW(SuperviseOW):
                 ):
                     self.__scan._cor_params.frame_width = self.__scan.dim_1
 
-                self.__scan._cor_params.set_relative_value(
-                    self._cor_params.relative_cor_value
-                )
+                relative_cor_value = self.getConfiguration().get("relative_cor_value")
+                self.__scan._cor_params.set_relative_value(relative_cor_value)
                 relative_cor_value = self.__scan.cor_params.relative_cor_value
                 save_reconstruction_parameters_to_cache(scan=self.__scan)
                 pv_helpers.notify_succeed(
@@ -337,18 +279,19 @@ class CoROW(SuperviseOW):
         msg.exec()
 
     def _updateSettingsVals(self):
-        # remove rp setting to the advantage of 'static_input'
-        cor_params = self._cor_params.to_dict()
+        params = self.getConfiguration()
+        # make sure serialization is correct
+        CoRParams(**params)
         self._ewoks_default_inputs = {
             "data": None,
-            ParametersKeys.COR_PARAMS_KEY: cor_params,
+            ParametersKeys.COR_PARAMS_KEY: params,
             "gui": {
                 "mode_is_lock": self.isModeLocked(),
                 "value_is_lock": self.isValueLock(),
                 "auto_update_estimated_cor": self._widget.getAutoUpdateEstimatedCor(),
                 "y_axis_inverted": self._widget.isYAxisInverted(),
             },
-            "relative_value": cor_params.get("POSITION_VALUE"),
+            "relative_value": params.get("relative_cor_value"),
         }
 
     def _skip_exec(self, b):
@@ -401,7 +344,7 @@ class CoROW(SuperviseOW):
             return
 
         self.__scan = scan
-        self._cor_params.frame_width = scan.dim_1
+        self._widget.setFrameWidth(scan.dim_1)
 
         # process manually
         process_manually = not (self.isValueLock() or self.isModeLocked())
@@ -413,6 +356,16 @@ class CoROW(SuperviseOW):
 
         self.__compute()
 
+    def getConfiguration(self) -> dict:
+        return self._widget.getConfiguration()
+
+    def setConfiguration(self, config: dict) -> None:
+        try:
+            self._cor_params = CoRParams(**config)
+        except Exception as e:
+            logger.warning(f"Fail to create CoRParams from config: {e}")
+        self._widget.setConfiguration(config)
+
     def _updatePosition(self, scan):
         if scan.cor_params is not None:
             self._widget.setPosition(relative_value=scan.cor_params.relative_cor_value)
@@ -451,9 +404,6 @@ class CoROW(SuperviseOW):
     def setEstimatedCor(self, value):
         self._widget.setEstimatedCor(value=value)
 
-    def getAxisParams(self):
-        return self._widget.getAxisParams()
-
     def setValueLock(self, lock: bool):
         self._widget.setValueLock(lock=lock)
 

{tomwer-2.0.0.dev5 → tomwer-2.0.0.dev7}/src/orangecontrib/tomwer/widgets/reconstruction/MultiCoROW.py

@@ -20,7 +20,7 @@ from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.reconstruction.multi.multicor.multicor import _is_margin_too_large
 from tomwer.core.reconstruction.common.phase import NabuPhaseMethod
 from tomwer.core.settings import ParametersKeys
-from tomwer.gui.reconstruction.cor.QCoRParams import QCoRParams as _QCoRParams
+from tomwer.models.reconstruction.cor import CoRParams
 from tomwer.gui.reconstruction.multicor.QMultiCoRParams import (
     QMultiCoRParams as _QMultiCoRParams,
 )
@@ -199,7 +199,7 @@ class MultiCoROW(
         self._widget.setConfiguration(configuration)
 
     @Inputs.data
-    def _scanReceived(self, scan):
+    def _scanReceived(self, scan, *args, **kwargs):
         self.process(scan=scan)
 
     def process(self, scan):
@@ -209,7 +209,7 @@ class MultiCoROW(
         if scan is None:
             return
         if scan.cor_params is None:
-            scan.cor_params = _QCoRParams()
+            scan.cor_params = CoRParams()
         if scan.multicor_params is None:
             scan.multicor_params = _QMultiCoRParams()
         if not check_nabu_params_are_provided(

{tomwer-2.0.0.dev5 → tomwer-2.0.0.dev7}/src/orangecontrib/tomwer/widgets/reconstruction/MultiPagOW.py

@@ -11,7 +11,7 @@ from silx.gui import qt
 import tomwer.tasks.reconstruction.multipag
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import ParametersKeys
-from tomwer.gui.reconstruction.cor.QCoRParams import QCoRParams as _QCoRParams
+from tomwer.models.reconstruction.cor import CoRParams
 from tomwer.gui.reconstruction.multipag.QMultiPagParams import (
     QMultiPagParams as _QMultiPagParams,
 )
@@ -155,14 +155,14 @@ class MultiPagOW(
         return self._widget.isAutoFocusLock()
 
     @Inputs.data
-    def _scanReceived(self, scan):
+    def _scanReceived(self, scan, *args, **kwargs):
         self.process(scan=scan)
 
     def process(self, scan):
         if scan is None:
             return
         if scan.cor_params is None:
-            scan.cor_params = _QCoRParams()
+            scan.cor_params = CoRParams()
         if scan.multipag_params is None:
             scan.multipag_params = _QMultiPagParams()
         if not check_nabu_params_are_provided(

{tomwer-2.0.0.dev5 → tomwer-2.0.0.dev7}/src/orangecontrib/tomwer/widgets/reconstruction/NabuSlicesOW.py

@@ -24,7 +24,7 @@ from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.core.settings import ParametersKeys
 from tomwer.gui.reconstruction.nabu.slices.NabuSlicesWindow import NabuSlicesWindow
-from tomwer.gui.reconstruction.cor.QCoRParams import QCoRParams as _QCoRParams
+from tomwer.models.reconstruction.cor import CoRParams as _CoRParams
 from tomwer.gui.utils.reconstruction import check_nabu_params_are_provided
 from tomwer.synctools.stacks.reconstruction.nabu import NabuSliceProcessStack
 
@@ -170,7 +170,7 @@ class NabuSlicesOW(SuperviseOW, BaseNabuRecOW):
         if scan.cor_params is None or scan.cor_params.relative_cor_value is None:
             # try to retrieve last computed cor value from nabu process
             if scan.cor_params is None:
-                scan.cor_params = _QCoRParams()
+                scan.cor_params = _CoRParams()
             load_reconstruction_parameters_from_cache(scan=scan)
 
         self.show()
@@ -238,7 +238,7 @@ class NabuSlicesOW(SuperviseOW, BaseNabuRecOW):
     def getConfiguration(self, allow_no_nabu_config_defined: bool = False):
         """
         :param allow_no_nabu_config_defined: when we save the settings we don't want to raise an error when saving the configuration.
-        But when getting it for reconstructing we want to
+            But when getting it for reconstructing we want to
         """
         slices_config = self._nabuWidget.getConfiguration()
         nabu_param_and_cluster_config = super().getConfiguration()

{tomwer-2.0.0.dev5 → tomwer-2.0.0.dev7}/src/orangecontrib/tomwer/widgets/reconstruction/NabuVolumeOW.py

@@ -23,6 +23,7 @@ from tomwer.core.utils.dictutils import concatenate_dict
 from tomwer.core.settings import ParametersKeys
 from tomwer.core.volume.volumebase import TomwerVolumeBase
 from tomwer.core.volume.volumefactory import VolumeFactory
+from tomwer.models.reconstruction.cor import CoRParams as _CoRParams
 from tomwer.gui.reconstruction.nabu.volume.NabuVolumeWindow import NabuVolumeWindow
 from tomwer.gui.utils.reconstruction import check_nabu_params_are_provided
 from tomwer.synctools.stacks.reconstruction.nabu import NabuVolumeProcessStack
@@ -156,11 +157,7 @@ class NabuVolumeOW(SuperviseOW, BaseNabuRecOW):
         if dataset.cor_params is None or dataset.cor_params.relative_cor_value is None:
             # try to retrieve last computed cor value from nabu process
             if dataset.cor_params is None:
-                from tomwer.gui.reconstruction.cor.QCoRParams import (
-                    QCoRParams as _QCoRParams,
-                )
-
-                dataset.cor_params = _QCoRParams()
+                dataset.cor_params = _CoRParams()
             load_reconstruction_parameters_from_cache(scan=dataset)
 
         self.process(dataset)
@@ -261,7 +258,7 @@ class NabuVolumeOW(SuperviseOW, BaseNabuRecOW):
     def getConfiguration(self, allow_no_nabu_config_defined: bool = False):
         """
         :param allow_no_nabu_config_defined: when we save the settings we don't want to raise an error when saving the configuration.
-        But when getting it for reconstructing we want to
+            But when getting it for reconstructing we want to
         """
         nabu_params_and_slurm_config = super().getConfiguration()
         assert ParametersKeys.SLURM_CLUSTER_KEY in nabu_params_and_slurm_config

{tomwer-2.0.0.dev5 → tomwer-2.0.0.dev7}/src/tomwer/__main__.py

@@ -89,6 +89,11 @@ def main():
         description="Compute center of rotation of a scan or "
         "between two projections",
     )
+    launcher.add_command(
+        "cast-volume",
+        module_name="tomwer.app.cast_volume",
+        description="Cast a nabu volume to a different data type / file format",
+    )
     launcher.add_command(
         "canvas", module_name="tomwer.app.canvas", description="open the orange-canvas"
     )