tomwer 1.4.19__py3-none-any.whl → 1.5.2rc0__py3-none-any.whl

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

@@ -205,7 +205,7 @@ class _NabuBaseReconstructor:
         axis: NabuPlane = NabuPlane.XY,
     ) -> None:
         self._scan = scan
-        self._target = Target.from_value(target)
+        self._target = Target(target)
         self._dry_run = dry_run
         self._process_name = process_name
         self._process = None
@@ -564,7 +564,7 @@ class _NabuBaseReconstructor:
         )
 
         source = extra_infos.get("source", INormSource.NONE)
-        source = INormSource.from_value(source)
+        source = INormSource(source)
 
         if source is INormSource.NONE:
             pass

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

@@ -390,7 +390,7 @@ class _Reconstructor(_NabuBaseReconstructor):
             _config["reconstruction"]["end_z"] = self.slice_index
         else:
             raise ValueError(
-                f"self.axis has an invalid value: {self.axis} when expected to be in {NabuPlane.values()}"
+                f"self.axis has an invalid value: {self.axis} when expected to be in {[item.value for item in NabuPlane]}"
             )
         return _config, file_prefix
 

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

@@ -54,7 +54,7 @@ from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
 )
 from processview.core.superviseprocess import SuperviseProcess
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
@@ -612,7 +612,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 config["reconstruction"]["end_z"] = self.slice_index
             else:
                 raise ValueError(
-                    f"self.axis has an invalid value: {self.axis} when expected to be in {NabuPlane.values()}"
+                    f"self.axis has an invalid value: {self.axis} when expected to be in {[item.value for item in NabuPlane]}"
                 )
 
         if self.slice_index is not None:
@@ -842,7 +842,7 @@ class NabuSliceMode(_Enum):
     def getSlices(slices, scan, axis=NabuPlane.XY) -> tuple:
         res = []
         try:
-            mode = NabuSliceMode.from_value(slices)
+            mode = NabuSliceMode(slices)
         except ValueError:
             try:
                 res = utils.retrieve_lst_of_value_from_str(slices, type_=int)
@@ -850,7 +850,7 @@ class NabuSliceMode(_Enum):
                 pass
         else:
             if mode == mode.MIDDLE:
-                axis = NabuPlane.from_value(axis)
+                axis = NabuPlane(axis)
                 if axis is NabuPlane.XY:
                     n_slice = scan.dim_2 or 2048
                 elif axis in (NabuPlane.YZ, NabuPlane.XZ):

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

@@ -1,6 +1,6 @@
 """Define nabu Axis"""
 
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 class NabuPlane(_Enum):
@@ -16,4 +16,4 @@ class NabuPlane(_Enum):
             return NabuPlane.XZ
         elif value == 2:
             return NabuPlane.YZ
-        return super().from_value(value=value)
+        return NabuPlane(value=value)

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

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 class Target(_Enum):

tomwer/core/process/reconstruction/nabu/test/test_castvolume.py

@@ -107,6 +107,7 @@ def test_cast_volume_32bitstiff_to_16bits_tiff(tmp_path):
                 "output_dir": str(save_dir),
                 "output_file_format": NabuOutputFileFormat.HDF5,
                 "output_data_type": numpy.int16,
+                "remove_input_volume": True,
             },
             "output_volume": output_volume.get_identifier().to_str(),
         },
@@ -114,3 +115,4 @@ def test_cast_volume_32bitstiff_to_16bits_tiff(tmp_path):
     task.run()
     assert task.outputs.volume.load_data().shape == (20, 100, 100)
     assert task.outputs.volume.load_data().dtype == numpy.int16
+    assert not os.path.exists(volume.data_url.file_path())

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

@@ -10,7 +10,7 @@ from nabu.pipeline.config import generate_nabu_configfile, parse_nabu_config_fil
 from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
 )
-from silx.utils.enum import Enum as _Enum
+from enum import Enum
 
 from tomoscan.identifier import VolumeIdentifier
 import tomwer.version
@@ -240,13 +240,13 @@ def get_multi_cor_recons_volume_identifiers(
     return res
 
 
-class _NabuMode(_Enum):
+class _NabuMode(Enum):
     FULL_FIELD = "standard acquisition"
     HALF_ACQ = "half acquisition"
     # HELICAL = "helical acquisition"
 
 
-class _NabuStages(_Enum):
+class _NabuStages(Enum):
     INI = "initialization"
     PRE = "pre-processing"
     PHASE = "phase"
@@ -267,7 +267,7 @@ class _NabuStages(_Enum):
     @staticmethod
     def getProcessEnum(stage):
         """Return the process Enum associated to the stage"""
-        stage = _NabuStages.from_value(stage)
+        stage = _NabuStages(stage)
         if stage is _NabuStages.INI:
             raise NotImplementedError()
         elif stage is _NabuStages.PRE:
@@ -281,7 +281,7 @@ class _NabuStages(_Enum):
         raise NotImplementedError()
 
 
-class _NabuPreprocessing(_Enum):
+class _NabuPreprocessing(Enum):
     """Define all the preprocessing action possible and the order they
     are applied on"""
 
@@ -296,7 +296,7 @@ class _NabuPreprocessing(_Enum):
         )
 
 
-class _NabuPhase(_Enum):
+class _NabuPhase(Enum):
     """Define all the phase action possible and the order they
     are applied on"""
 
@@ -309,7 +309,7 @@ class _NabuPhase(_Enum):
         return (_NabuPhase.PHASE, _NabuPhase.UNSHARP_MASK, _NabuPhase.LOGARITHM)
 
 
-class _NabuProcessing(_Enum):
+class _NabuProcessing(Enum):
     """Define all the processing action possible"""
 
     RECONSTRUCTION = "reconstruction"
@@ -319,7 +319,7 @@ class _NabuProcessing(_Enum):
         return (_NabuProcessing.RECONSTRUCTION,)
 
 
-class _NabuPostProcessing(_Enum):
+class _NabuPostProcessing(Enum):
     """Define all the post processing action available"""
 
     SAVE_DATA = "save"
@@ -329,11 +329,12 @@ class _NabuPostProcessing(_Enum):
         return (_NabuPostProcessing.SAVE_DATA,)
 
 
-class _NabuReconstructionMethods(_Enum):
+class _NabuReconstructionMethods(Enum):
     FBP = "FBP"
+    MLEM = "MLEM"
 
 
-class _NabuPhaseMethod(_Enum):
+class _NabuPhaseMethod(Enum):
     """
     Nabu phase method
     """
@@ -354,10 +355,10 @@ class _NabuPhaseMethod(_Enum):
             elif value.lower() == "ctf":
                 return _NabuPhaseMethod.CTF
         else:
-            return super().from_value(value=value)
+            return _NabuPhaseMethod(value=value)
 
 
-class _NabuFBPFilterType(_Enum):
+class _NabuFBPFilterType(Enum):
     RAMLAK = "ramlak"
     SHEPP_LOGAN = "shepp-logan"
     COSINE = "cosine"
@@ -368,12 +369,12 @@ class _NabuFBPFilterType(_Enum):
     HILBERT = "hilbert"
 
 
-class _NabuPaddingType(_Enum):
+class _NabuPaddingType(Enum):
     ZEROS = "zeros"
     EDGES = "edges"
 
 
-class RingCorrectionMethod(_Enum):
+class RingCorrectionMethod(Enum):
     NONE = "None"
     MUNCH = "munch"
     VO = "vo"

tomwer/core/process/reconstruction/normalization/normalization.py

@@ -140,7 +140,7 @@ class SinoNormalizationTask(
         if calc_fct is None:
             raise ValueError("calc_fct should be provided")
         else:
-            calc_fct = _ValueCalculationFct.from_value(calc_fct)
+            calc_fct = _ValueCalculationFct(calc_fct)
 
         try:
             value = self._cache_compute_from_manual_roi(

tomwer/core/process/reconstruction/normalization/params.py

@@ -4,7 +4,7 @@ material for radio and sinogram normalization
 """
 from __future__ import annotations
 
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from tomoscan.normalization import Method
 
 
@@ -39,7 +39,7 @@ class _DatasetInfos:
 
     @scope.setter
     def scope(self, scope: str | _DatasetScope):
-        self._scope = _DatasetScope.from_value(scope)
+        self._scope = _DatasetScope(scope)
 
     @property
     def file_path(self):
@@ -86,7 +86,7 @@ class SinoNormalizationParams:
     def method(self, method: str | Method | None):
         if method is None:
             method = Method.NONE
-        self._method = Method.from_value(method)
+        self._method = Method(method)
 
     @property
     def source(self):
@@ -96,7 +96,7 @@ class SinoNormalizationParams:
     def source(self, source):
         if source is None:
             source = _ValueSource.NONE
-        self._source = _ValueSource.from_value(source)
+        self._source = _ValueSource(source)
 
     @property
     def extra_infos(self):

tomwer/core/process/reconstruction/output.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import os
 import logging
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 from tomwer.io.utils.raw_and_processed_data import (
     to_processed_data_path,
 )
@@ -30,7 +30,7 @@ class NabuOutputFileFormat(_Enum):
     def from_value(cls, value):
         if isinstance(value, str):
             value = value.lstrip(".")
-        return super().from_value(value)
+        return NabuOutputFileFormat(value)
 
 
 def get_file_format(file_str):

tomwer/core/process/reconstruction/saaxis/params.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from typing import Iterable
 
 import numpy
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomwer.core.process.reconstruction.scores.params import SABaseParams
 
@@ -56,7 +56,7 @@ class SAAxisParams(SABaseParams):
 
     @mode.setter
     def mode(self, mode):
-        mode = ReconstructionMode.from_value(mode)
+        mode = ReconstructionMode(mode)
         self._mode = mode
 
     @property
@@ -91,7 +91,7 @@ class SAAxisParams(SABaseParams):
         if "n_reconstruction" in dict_:
             self.n_reconstruction = dict_["n_reconstruction"]
         if "mode" in dict_:
-            self.mode = ReconstructionMode.from_value(dict_["mode"])
+            self.mode = ReconstructionMode(dict_["mode"])
 
     @staticmethod
     def from_dict(dict_):

tomwer/core/process/reconstruction/saaxis/saaxis.py

@@ -430,7 +430,7 @@ class SAAxisTask(
             params.image_width = scan.dim_1
         scan.saaxis_params = params
 
-        mode = ReconstructionMode.from_value(params.mode)
+        mode = ReconstructionMode(params.mode)
         if mode is not ReconstructionMode.VERTICAL:
             raise ValueError(f"{mode} is not handled for now")
 

tomwer/core/process/reconstruction/scores/params.py

@@ -102,7 +102,7 @@ class SABaseParams:
 
     @score_method.setter
     def score_method(self, method):
-        self._score_method = ScoreMethod.from_value(method)
+        self._score_method = ScoreMethod(method)
 
     @property
     def scores(self) -> dict | None:
@@ -170,7 +170,7 @@ class SABaseParams:
                 output_dir = None
             self.output_dir = output_dir
         if "score_method" in dict_:
-            self.score_method = ScoreMethod.from_value(dict_["score_method"])
+            self.score_method = ScoreMethod(dict_["score_method"])
         if "cluster_config" in dict_:
             if dict_["cluster_config"] in (None, ""):
                 self.cluster_config = None

tomwer/core/process/reconstruction/scores/scores.py

@@ -4,7 +4,7 @@ import logging
 import sys
 
 import numpy
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 _logger = logging.getLogger(__name__)
 
@@ -36,7 +36,7 @@ class ComputedScore:
         return self._tomo_consistency
 
     def get(self, method: ScoreMethod):
-        method = ScoreMethod.from_value(method)
+        method = ScoreMethod(method)
         if method is ScoreMethod.TV:
             return self.total_variation / float(10e5)
         elif method is ScoreMethod.TV_INVERSE:
@@ -135,7 +135,7 @@ def compute_score(
     :param method:
     :return: score of the frame
     """
-    method = ScoreMethod.from_value(method)
+    method = ScoreMethod(method)
     if data.ndim == 3:
         if data.shape[0] == 1:
             data = data.reshape(data.shape[1], data.shape[2])

tomwer/core/process/reconstruction/tests/test_axis.py

@@ -40,7 +40,7 @@ def test_read_x_rotation_axis_pixel_position(nxtomo_scan_360):  # noqa F811
     with h5py.File(nxtomo_scan_360.master_file, mode="a") as h5f:
         h5f[x_rotation_axis_pixel_position_path] = 12.5
 
-    nxtomo_scan_360.clear_caches()
+    nxtomo_scan_360.clear_cache()
     task.run()
     assert nxtomo_scan_360.axis_params.absolute_cor_value == 22.5
     assert nxtomo_scan_360.axis_params.relative_cor_value == 12.5

tomwer/core/process/stitching/metadataholder.py

@@ -41,19 +41,19 @@ class StitchingMetadata:
         if value is not None and not isinstance(
             value, (float, numpy.float32, numpy.float64)
         ):
-            raise TypeError
+            raise TypeError(f"Invalid type for value. Got {type(value)}")
         self._pixel_or_voxel_size[axis] = value
 
     def setPxPos(self, value, axis):
         if value is not None and not isinstance(value, (int, numpy.int32)):
-            raise TypeError
+            raise TypeError(f"Invalid type for value. Got {type(value)}")
         self._pos_as_px[axis] = value
 
     def setMetricPos(self, value, axis):
         if value is not None and not isinstance(
             value, (int, numpy.float32, numpy.float64, float)
         ):
-            raise TypeError
+            raise TypeError(f"Invalid type for value. Got {type(value)}")
         self._pos_as_m[axis] = value
 
     def get_raw_position_m(self, axis):
@@ -111,9 +111,9 @@ class StitchingMetadata:
             return self._pixel_or_voxel_size[axis]
         elif isinstance(self.tomo_obj, TomoScanBase):
             if axis == 0:
-                return self.tomo_obj.y_pixel_size
+                return self.tomo_obj.sample_y_pixel_size
             elif axis in (1, 2):
-                return self.tomo_obj.x_pixel_size
+                return self.tomo_obj.sample_x_pixel_size
             else:
                 raise TypeError(f"axis is expected to be in (0, 1, 2). {axis} provided")
         elif isinstance(self.tomo_obj, VolumeBase):

tomwer/core/process/stitching/nabustitcher.py

@@ -162,12 +162,9 @@ class StitchingPostProcAggregation(_StitchingPostProcAggregation):
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        print("creates StitchingPostProcAggregation")
 
         if isinstance(self.stitching_config, dict):
-            stitching_type = StitchingType.from_value(
-                self.stitching_config["stitching"]["type"]
-            )
+            stitching_type = StitchingType(self.stitching_config["stitching"]["type"])
             if stitching_type is StitchingType.Z_PREPROC:
                 self._stitching_config = PreProcessedZStitchingConfiguration.from_dict(
                     self.stitching_config

tomwer/core/process/tests/test_normalization.py

@@ -54,7 +54,8 @@ class TestNormalization(unittest.TestCase):
             "median": numpy.array([800.5, 10800.5]),
         }
 
-        for calc_fct in params._ValueCalculationFct.values():
+        for item in params._ValueCalculationFct:
+            calc_fct = item.value
             with self.subTest(calc_fct=calc_fct):
                 process_params.extra_infos = {
                     "start_x": 0,

tomwer/core/scan/edfscan.py

@@ -127,9 +127,9 @@ class EDFTomoScan(_tsEDFTomoScan, TomwerScanBase):
             )
         return EDFTomoScan(scan=identifier.folder)
 
-    def clear_caches(self):
-        _tsEDFTomoScan.clear_caches(self)
-        TomwerScanBase.clear_caches(self)
+    def clear_cache(self):
+        _tsEDFTomoScan.clear_cache(self)
+        TomwerScanBase.clear_cache(self)
 
     @staticmethod
     def directory_contains_scan(directory, src_pattern, dest_pattern):

tomwer/core/scan/nxtomoscan.py

@@ -178,9 +178,9 @@ class NXtomoScan(_tsNXtomoScan, TomwerScanBase):
         else:
             return os.path.exists(master_file + ".h5")
 
-    def clear_caches(self):
-        _tsNXtomoScan.clear_caches(self)
-        TomwerScanBase.clear_caches(self)
+    def clear_cache(self):
+        _tsNXtomoScan.clear_cache(self)
+        TomwerScanBase.clear_cache(self)
 
     def is_abort(self, src_pattern, dest_pattern):
         """

tomwer/core/scan/scanbase.py

@@ -10,7 +10,7 @@ from typing import Iterable
 
 import numpy
 from silx.io.url import DataUrl
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 from tomoscan.identifier import VolumeIdentifier
 from tomoscan.normalization import IntensityNormalization
@@ -92,10 +92,10 @@ class TomwerScanBase(TomwerObject):
         """
         raise NotImplementedError("Base class")
 
-    def clear_caches(self):
+    def clear_cache(self):
         self._cache_proj_urls = None
         self._notify_ffc_rsc_missing = True
-        super().clear_caches()
+        super().clear_cache()
 
     def _flat_field_correction(
         self,

tomwer/core/scan/scantype.py

@@ -1,4 +1,4 @@
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 class ScanType(_Enum):

tomwer/core/settings.py

@@ -1,5 +1,5 @@
 import os
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 __LBSRAM_PATH = "/lbsram"

tomwer/core/tomwer_object.py

@@ -19,7 +19,7 @@ class TomwerObject(Dataset):
         """util function to clear some heavy object from the cache"""
         raise NotImplementedError()
 
-    def clear_caches(self):
+    def clear_cache(self):
         pass
 
     @property

tomwer/core/utils/nxtomoutils.py

@@ -11,12 +11,12 @@ def get_n_series(image_key_values: tuple | list, image_key_type: ImageKey) -> in
 
     :param image_key_values: list or tuple of image_keys to consider. Can be integers or tomoscan.esrf.scan.hdf5scan.ImageKey
     """
-    image_key_type = ImageKey.from_value(image_key_type)
+    image_key_type = ImageKey(image_key_type)
     if image_key_type is ImageKey.INVALID:
         raise ValueError(
             "we can't count Invalid image keys series because those are ignored from tomoscan"
         )
-    image_key_values = [ImageKey.from_value(img_key) for img_key in image_key_values]
+    image_key_values = [ImageKey(img_key) for img_key in image_key_values]
 
     # remove invalid frames
     image_key_values = numpy.array(

tomwer/core/utils/spec.py

@@ -3,14 +3,17 @@ from __future__ import annotations
 import fileinput
 import logging
 import os
+import pint
+
+import fabio
 
-import fabio.edfimage
 from lxml import etree
-from pyunitsystem.metricsystem import MetricSystem
 
 
 _logger = logging.getLogger(__name__)
 
+_ureg = pint.get_application_registry()
+
 
 def _getInformation(scan, refFile, information, _type, aliases=None):
     """
@@ -258,6 +261,6 @@ def getPixelSize(scan) -> float | None:
                 value = float(ddict["IMAGE_PIXEL_SIZE_1".lower()])
     # for now pixel size are stored in microns. We want to return them in meter
     if value is not None:
-        return value * MetricSystem.MICROMETER.value
+        return (value * _ureg.micrometer).to_base_units().magnitude
     else:
         return None

tomwer/gui/cluster/slurm.py

@@ -94,7 +94,7 @@ class SlurmSettingsWindow(qt.QMainWindow):
 
         self._modeCombox = qt.QComboBox(self)
         self._mainWidget.layout().addRow("configuration: ", self._modeCombox)
-        self._modeCombox.addItems(SlurmSettingsMode.values())
+        self._modeCombox.addItems([item.value for item in SlurmSettingsMode])
         self._modeCombox.setCurrentText(SlurmSettingsMode.GENERIC.value)
 
         self._settingsWidget = SlurmSettingsWidget(self, jobLimitation=None)
@@ -155,10 +155,10 @@ class SlurmSettingsWindow(qt.QMainWindow):
         self._modeCombox.setCurrentText(SlurmSettingsMode.MANUAL.value)
 
     def getCurrentSettingsMode(self) -> SlurmSettingsMode:
-        return SlurmSettingsMode.from_value(self._modeCombox.currentText())
+        return SlurmSettingsMode(self._modeCombox.currentText())
 
     def setCurrentSettingsMode(self, mode: SlurmSettingsMode) -> SlurmSettingsMode:
-        mode = SlurmSettingsMode.from_value(mode)
+        mode = SlurmSettingsMode(mode)
         self._modeCombox.setCurrentText(mode.value)
 
     def setMode(self, mode: SlurmSettingsMode) -> None:

tomwer/gui/configuration/level.py

@@ -1,4 +1,4 @@
-from silx.utils.enum import Enum as _Enum
+from enum import Enum as _Enum
 
 
 class ConfigurationLevel(_Enum):

tomwer/gui/control/actions.py

@@ -86,7 +86,7 @@ class TomoObjDisplayModeToolButton(qt.QToolButton):
         urlDescAction.triggered.connect(partial(self.setDisplayMode, DisplayMode.URL))
 
     def setDisplayMode(self, mode: DisplayMode):
-        mode = DisplayMode.from_value(mode)
+        mode = DisplayMode(mode)
         if mode is DisplayMode.SHORT:
             self.setIcon(self._shortDescIcon)
             self.setToolTip(self._SHORT_DESC_TOOLTIP)

tomwer/gui/control/datadiscovery.py

@@ -44,7 +44,7 @@ class ScanDiscoveryConfigWidget(qt.QGroupBox):
             raise NotImplementedError
 
     def setScanType(self, mode: ScanType):
-        mode = ScanType.from_value(mode)
+        mode = ScanType(mode)
         if mode is ScanType.SPEC:
             self._specQRB.setChecked(True)
         elif mode is ScanType.BLISS:

tomwer/gui/control/datalist.py

@@ -616,7 +616,7 @@ class _TomwerObjectList(qt.QTableWidget):
         self.setDisplayMode(DisplayMode.SHORT)
 
     def setDisplayMode(self, mode: DisplayMode) -> None:
-        self._displayMode = DisplayMode.from_value(mode)
+        self._displayMode = DisplayMode(mode)
         self._update()
 
     def n_data(self):

tomwer/gui/control/reducedarkflatselector.py

@@ -287,11 +287,11 @@ class ReduceDarkFlatSelectorTableWidget(qt.QWidget):
                 h5file=url.file_path(),
                 path=url.data_path(),
             )
-            for target in REDUCER_TARGET.values():
-                if target in reduced_info_dict:
-                    reduced_frames = reduced_info_dict[target]
+            for target in REDUCER_TARGET:
+                if target.value in reduced_info_dict:
+                    reduced_frames = reduced_info_dict[target.value]
                     reduced_frames["reduce_frames_name"] = (
-                        f"{target} from {url.data_path()}@{os.path.basename(url.file_path())}"
+                        f"{target.value} from {url.data_path()}@{os.path.basename(url.file_path())}"
                     )
                     result.append(reduced_frames)