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

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/params.py

@@ -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):

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/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/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

@@ -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/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/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/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)
 

tomwer/gui/edit/imagekeyeditor.py

@@ -112,9 +112,7 @@ class ImageKeyWindow(qt.QMainWindow):
     def setModifications(self, modifications):
         self._mainWindow.clearModifcations()
         image_keys_set = set(modifications.values())
-        image_keys_set = set(
-            [_ImageKey.from_value(image_key) for image_key in image_keys_set]
-        )
+        image_keys_set = set([_ImageKey(image_key) for image_key in image_keys_set])
         for image_key_type in image_keys_set:
             self._mainWindow.applyModifications(
                 modifications=modifications, new_image_key=image_key_type
@@ -432,7 +430,7 @@ class _ImageKeyList(qt.QTableWidget):
             self.setItem(i_frame, 0, _item)
 
             # current image key
-            current_image_key = _ImageKey.from_value(frame.image_key)
+            current_image_key = _ImageKey(frame.image_key)
             current_image_key = self._IMAGE_KEYS_INV[current_image_key]
             currentImgKeyItem = qt.QLabel(current_image_key, self)
             self.setCellWidget(i_frame, 1, currentImgKeyItem)
@@ -442,7 +440,7 @@ class _ImageKeyList(qt.QTableWidget):
                 new_image_key = frames_new_keys[frame.index]
             else:
                 new_image_key = frame.image_key
-            new_image_key = _ImageKey.from_value(new_image_key)
+            new_image_key = _ImageKey(new_image_key)
             new_image_key = self._IMAGE_KEYS_INV[new_image_key]
             newImgKeyItem = _ImageKeyComboBox(parent=self, image_key=new_image_key)
             self._imageKeyComboboxes[index] = newImgKeyItem
@@ -694,16 +692,16 @@ class ImageKeyUpgraderList(qt.QTableWidget):
             self.setCellWidget(i_operation, 1, remove_button)
 
     def addOperation(self, from_image_key: _ImageKey, to_image_key: _ImageKey):
-        from_image_key = _ImageKey.from_value(from_image_key)
-        to_image_key = _ImageKey.from_value(to_image_key)
+        from_image_key = _ImageKey(from_image_key)
+        to_image_key = _ImageKey(to_image_key)
 
         self._operations[from_image_key] = to_image_key
         self._update()
         self.sigOperationsChanged.emit()
 
     def removeOperation(self, from_image_key: _ImageKey, to_image_key: _ImageKey):
-        from_image_key = _ImageKey.from_value(from_image_key)
-        to_image_key = _ImageKey.from_value(to_image_key)
+        from_image_key = _ImageKey(from_image_key)
+        to_image_key = _ImageKey(to_image_key)
         if (
             from_image_key not in self._operations
             or self._operations[from_image_key] != to_image_key