tomwer 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

tomwer/core/utils/scanutils.py

@@ -29,10 +29,12 @@ __authors__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "11/08/2022"
 
+import logging
 import h5py
 import numpy
 import time
 import os
+from typing import Any
 from tomoscan.io import HDF5File
 from tomoscan.esrf.scan.mock import MockEDF as _MockEDF, MockHDF5 as _MockHDF5
 from tomoscan.test.utils import MockContext
@@ -41,6 +43,8 @@ from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanfactory import ScanFactory
 from silx.io.utils import h5py_read_dataset
 
+_logger = logging.getLogger(__name__)
+
 
 class MockHDF5(_MockHDF5):
     def __init__(self, *args, **kwargs):
@@ -391,3 +395,49 @@ class HDF5MockContext(MockContext, mock_class=MockHDF5):
         return MockHDF5(
             scan_path=self._scan_path, n_proj=self._n_proj, **self._mocks_params
         ).scan
+
+
+def data_identifier_to_scan(data_identifier: Any):
+    """
+    from a identifier (as str) try to create a scan.
+    Mostly used when 'data' parameter is set from ewoks. In this case we expect it to be a (string) identifier
+    """
+    if isinstance(data_identifier, str):
+        return ScanFactory.create_tomo_object_from_identifier(data_identifier)
+    else:
+        return data_identifier
+
+
+def format_output_location(location: str, scan):
+    """
+    format possible keys from the location like {scan_dir} or {scan_path}
+
+    :param location:
+    :param scan:
+    :return:
+    """
+    if scan is None:
+        _logger.warning("scan is !none, enable to format the nabu output location")
+
+    keywords = {
+        "scan_dir_name": scan.scan_dir_name(),
+        "scan_basename": scan.scan_basename(),
+        "scan_parent_dir_basename": scan.scan_parent_dir_basename(),
+    }
+
+    # filter necessary keywords
+    def get_necessary_keywords():
+        import string
+
+        formatter = string.Formatter()
+        return [field for _, field, _, _ in formatter.parse(location) if field]
+
+    requested_keywords = get_necessary_keywords()
+
+    def keyword_needed(pair):
+        keyword, _ = pair
+        return keyword in requested_keywords
+
+    keywords = dict(filter(keyword_needed, keywords.items()))
+    location = os.path.abspath(location.format(**keywords))
+    return location

tomwer/core/utils/volumeutils.py

@@ -0,0 +1,13 @@
+from tomwer.core.volume.volumefactory import VolumeFactory
+from typing import Any
+
+
+def volume_identifier_to_volume(volume_identifier: Any):
+    """
+    from a str identifier try to create a volume.
+    Mostly used when 'volume' parameter is set from ewoks. In this case we expect it to be a (string) identifier
+    """
+    if isinstance(volume_identifier, str):
+        return VolumeFactory.create_tomo_object_from_identifier(volume_identifier)
+    else:
+        return volume_identifier

tomwer/core/volume/edfvolume.py

@@ -49,6 +49,10 @@ class EDFVolumeIdentifier(_EDFVolumeIdentifier, DatasetIdentifier):
             ObjClass=EDFVolume,
         )
 
+    def long_description(self) -> str:
+        """used for processview header tooltip for now"""
+        return self.to_str()
+
 
 class EDFVolume(_EDFVolume, TomwerVolumeBase, Dataset):
     @staticmethod

tomwer/core/volume/hdf5volume.py

@@ -69,6 +69,10 @@ class HDF5VolumeIdentifier(_HDF5VolumeIdentifier, DatasetIdentifier):
             raise ValueError("expects to get a data_path")
         return HDF5VolumeIdentifier(object=HDF5Volume, hdf5_file=hdf5_file, entry=entry)
 
+    def long_description(self) -> str:
+        """used for processview header tooltip for now"""
+        return self.to_str()
+
 
 class HDF5Volume(_HDF5Volume, TomwerVolumeBase, Dataset):
     @staticmethod

tomwer/core/volume/jp2kvolume.py

@@ -51,6 +51,10 @@ class JP2KVolumeIdentifier(_JP2KVolumeIdentifier, DatasetIdentifier):
             ObjClass=JP2KVolume,
         )
 
+    def long_description(self) -> str:
+        """used for processview header tooltip for now"""
+        return self.to_str()
+
 
 class JP2KVolume(_JP2KVolume, TomwerVolumeBase, Dataset):
     @staticmethod

tomwer/core/volume/rawvolume.py

@@ -64,6 +64,10 @@ class RawVolumeIdentifier(_RawVolumeIdentifier, DatasetIdentifier):
             )
         return RawVolumeIdentifier(object=RawVolume, file_path=vol_file)
 
+    def long_description(self) -> str:
+        """used for processview header tooltip for now"""
+        return self.to_str()
+
 
 class RawVolume(_RawVolume, TomwerVolumeBase, Dataset):
     @staticmethod

tomwer/core/volume/tiffvolume.py

@@ -54,6 +54,10 @@ class TIFFVolumeIdentifier(_TIFFVolumeIdentifier, DatasetIdentifier):
             ObjClass=TIFFVolume,
         )
 
+    def long_description(self) -> str:
+        """used for processview header tooltip for now"""
+        return self.to_str()
+
 
 class MultiTiffVolumeIdentifier(_MultiTiffVolumeIdentifier, DatasetIdentifier):
     def __init__(self, object, tiff_file):

tomwer/core/volume/volumebase.py

@@ -3,14 +3,12 @@ from tomwer.core.tomwer_object import TomwerObject
 
 
 class TomwerVolumeBase(TomwerObject):
-    def get_identifier(self):
-        return self.get_identifier()
-
     def _clear_heavy_cache(self):
         """util user"""
         self.data = None
         self.metadata = None
 
+    @staticmethod
     def format_output_location(location: str, volume):
         if not isinstance(volume, TomwerVolumeBase):
             raise TypeError(
@@ -20,20 +18,29 @@ class TomwerVolumeBase(TomwerObject):
         keywords = {
             "volume_data_parent_folder": volume.volume_data_parent_folder(),
         }
-        for keyword, value in keywords.items():
-            if value is None:
-                continue
-            try:
-                location = location.format(**{keyword: value})
-            except KeyError:
-                pass
+
+        # filter necessary keywords
+        def get_necessary_keywords():
+            import string
+
+            formatter = string.Formatter()
+            return [field for _, field, _, _ in formatter.parse(location) if field]
+
+        requested_keywords = get_necessary_keywords()
+
+        def keyword_needed(pair):
+            keyword, _ = pair
+            return keyword in requested_keywords
+
+        keywords = dict(filter(keyword_needed, keywords.items()))
+        location = os.path.abspath(location.format(**keywords))
         return location
 
     def volume_data_parent_folder(self):
-        if self.data_url is None:
+        if self.data_url is None:  # pylint: disable=E1101
             raise ValueError("data_url doesn't exists")
         else:
-            return os.path.dirname(self.data_url.file_path())
+            return os.path.dirname(self.data_url.file_path())  # pylint: disable=E1101
 
     def __str__(self) -> str:
         try:

tomwer/core/volume/volumefactory.py

@@ -28,6 +28,7 @@ __license__ = "MIT"
 __date__ = "13/07/2022"
 
 
+from typing import Optional
 from urllib.parse import urlparse
 from typing import Union
 from tomoscan.factory import Factory as _oVolumeFactory
@@ -60,6 +61,22 @@ _logger = logging.getLogger(__name__)
 
 
 class VolumeFactory(_oVolumeFactory):
+    @staticmethod
+    def from_identifier_to_vol_urls(identifier) -> Optional[tuple]:
+        """
+        convert an identifier to a volume
+        and return all the existing url of this volume
+        """
+        try:
+            vol = VolumeFactory.create_tomo_object_from_identifier(
+                identifier=identifier
+            )
+        except Exception as e:
+            _logger.error(e)
+            return None
+        else:
+            return tuple(vol.browse_data_urls())
+
     @docstring(_oVolumeFactory.create_tomo_object_from_identifier)
     @staticmethod
     def create_tomo_object_from_identifier(identifier: Union[str, BaseIdentifier]):
@@ -74,7 +91,9 @@ class VolumeFactory(_oVolumeFactory):
         :rtype: tomwer.core.scan.scanbase.TomwerScanBase
         :raises: ValueError if scan_path is not containing a scan
         """
-        if not isinstance(identifier, (str, BaseIdentifier)):
+        if isinstance(identifier, BaseIdentifier):
+            identifier = identifier.to_str()
+        elif not isinstance(identifier, str):
             raise TypeError(
                 f"identifier is expected to be a str or an instance of {BaseIdentifier} not {type(identifier)}"
             )

tomwer/gui/cluster/slurm.py

@@ -162,7 +162,7 @@ class SlurmSettingsWidget(qt.QWidget):
         self._nCores.setValue(SlurmSettings.N_CORES_PER_TASK)
         self._nWorkers.setValue(SlurmSettings.N_TASKS)
         self._memory.setValue(SlurmSettings.MEMORY_PER_WORKER)
-        self._queue.setText(SlurmSettings.PARTIION)
+        self._queue.setText(SlurmSettings.PARTITION)
         self._nGpu.setValue(SlurmSettings.N_GPUS_PER_WORKER)
         self._jobName.setText(SlurmSettings.PROJECT_NAME)
         self._wallTimeQLE.setText(SlurmSettings.DEFAULT_WALLTIME)

tomwer/gui/cluster/test/test_cluster.py

@@ -31,7 +31,7 @@ from tomwer.gui.reconstruction.nabu.slurm import SlurmSettingsWidget
 from tomwer.core.settings import SlurmSettings
 from silx.gui.utils.testutils import TestCaseQt
 from silx.gui import qt
-from tomwer.test.utils import skip_gui_test
+from tomwer.tests.utils import skip_gui_test
 import pytest
 
 
@@ -54,7 +54,7 @@ class TestSlurmWidget(TestCaseQt):
             "cpu-per-task": SlurmSettings.N_CORES_PER_TASK,
             "n_tasks": SlurmSettings.N_TASKS,
             "memory": SlurmSettings.MEMORY_PER_WORKER,
-            "partition": SlurmSettings.PARTIION,
+            "partition": SlurmSettings.PARTITION,
             "n_gpus": SlurmSettings.N_GPUS_PER_WORKER,
         }
         assert dict_res == expected_dict, f"{dict_res} vs {expected_dict}"

tomwer/gui/control/datalist.py

@@ -66,6 +66,7 @@ from nxtomomill.io.config import TomoHDF5Config as HDF5Config
 from nxtomomill.io.config import TomoEDFConfig as EDFConfig
 from nxtomomill.io import generate_default_edf_config
 from nxtomomill.io import generate_default_h5_config
+from tomwer.gui.utils.qt_utils import block_signals
 
 logger = logging.getLogger(__name__)
 
@@ -222,9 +223,6 @@ class _NXtomomillConfigFileDialog(qt.QDialog):
     def accept(self):
         self.hide()
 
-    def _createDefaultConfigFile(self):
-        raise NotImplementedError
-
     def _createConfigFileSelector(self):
         raise NotImplementedError
 
@@ -245,7 +243,7 @@ class BlissHDF5DataListDialog(_DataListDialog):
     def createDataList(self):
         return BlissScanList(self)
 
-    def _callbackAddPath(self):
+    def _callbackAddPath(self):  # pragma: no cover
         """ """
         dialog = qt.QFileDialog(self)
         dialog.setNameFilters(["HDF5 file *.h5 *.hdf5 *.nx *.nexus", "nxs"])
@@ -280,7 +278,7 @@ class EDFDataListDialog(_DataListDialog):
     def createDataList(self):
         return EDFDataList(self)
 
-    def _callbackAddPath(self):
+    def _callbackAddPath(self):  # pragma: no cover
         """ """
         dialog = qt.QFileDialog(self)
         dialog.setFileMode(qt.QFileDialog.DirectoryOnly)
@@ -408,14 +406,14 @@ class _RawDataListMainWindow(qt.QMainWindow):
             else:
                 return config
 
-    def createNXtomomillConfigFileDialog(self):
+    def createNXtomomillConfigFileDialog(self):  # pragma: no cover
         file_dialog = qt.QFileDialog()
         file_dialog.setAcceptMode(qt.QFileDialog.AcceptSave)
         file_dialog.setWindowTitle("Select file path to save configuration file")
         file_dialog.setNameFilters(
             [
                 "Any file (*)",
-                "Configuration file (*.txt *.cfg *.conf)",
+                "Configuration file (*.txt *.cfg *.conf *.config)",
             ]
         )
         file_dialog.setFileMode(qt.QFileDialog.AnyFile)
@@ -442,7 +440,7 @@ class BlissHDF5DataListMainWindow(_RawDataListMainWindow):
             **kwargs,
         )
 
-    def _createNewConfigFile(self):
+    def _createNewConfigFile(self):  # pragma: no cover
         file_dialog = self.createNXtomomillConfigFileDialog()
         if file_dialog.exec_():
             files_selected = file_dialog.selectedFiles()
@@ -477,7 +475,7 @@ class EDFDataListMainWindow(_RawDataListMainWindow):
             **kwargs,
         )
 
-    def _createNewConfigFile(self):
+    def _createNewConfigFile(self):  # pragma: no cover
         file_dialog = self.createNXtomomillConfigFileDialog()
         if file_dialog.exec_():
             files_selected = file_dialog.selectedFiles()
@@ -498,7 +496,7 @@ class GenericScanListDialog(_DataListDialog):
     def createDataList(self):
         return GenericScanList(self)
 
-    def _callbackAddPath(self):
+    def _callbackAddPath(self):  # pragma: no cover
         """ """
         dialog = QDataDialog(self, multiSelection=True)
         dialog.setNameFilters(
@@ -527,7 +525,7 @@ class VolumeListDialog(_DataListDialog):
     def createDataList(self):
         return VolumeList(self)
 
-    def _callbackAddPath(self):
+    def _callbackAddPath(self):  # pragma: no cover
         """ """
         dialog = QVolumeDialog(self)
 
@@ -547,8 +545,11 @@ class _TomwerObjectList(qt.QTableWidget):
 
     dataReady = qt.Signal(TomwerObject)
 
+    listChanged = qt.Signal()
+    """emit when containt of the list changed"""
+
     def __init__(self, parent):
-        self._target = None
+        self._copy_target = None
         qt.QTableWidget.__init__(self, parent)
         self.setRowCount(0)
         self.setColumnCount(1)
@@ -562,12 +563,17 @@ class _TomwerObjectList(qt.QTableWidget):
         self.setAcceptDrops(True)
 
         self._myitems = OrderedDict()
+        # key is the TomoObject identifier and value is the QTableWidgetItem.
+        # Text is the identifier, QTableWidgetItem data under UserRole is the TomoObject object
 
         # QMenu
         self.menu = qt.QMenu(self)
         self._copyAction = qt.QAction("copy")
         self._copyAction.triggered.connect(self._copyRequested)
+        self._pasteAction = qt.QAction("paste")
+        self._pasteAction.triggered.connect(self._pasteRequested)
         self.menu.addAction(self._copyAction)
+        self.menu.addAction(self._pasteAction)
 
     def n_data(self):
         return len(self._myitems)
@@ -608,6 +614,7 @@ class _TomwerObjectList(qt.QTableWidget):
         else:
             item = self._myitems[identifier_as_str]
             self.remove_item(item)
+            self.listChanged.emit()
 
     def _update(self):
         tomwer_objects = [
@@ -615,9 +622,11 @@ class _TomwerObjectList(qt.QTableWidget):
             for identifier_as_str in self._myitems.keys()
         ]
         self.clear()
-        for tomwer_object in tomwer_objects:
-            self.add(tomwer_object)
+        with block_signals(self):
+            for tomwer_object in tomwer_objects:
+                self.add(tomwer_object)
         self.sortByColumn(0, self.horizontalHeader().sortIndicatorOrder())
+        self.listChanged.emit()
 
     def _getTomoObject(self, obj: str):
         """
@@ -665,7 +674,8 @@ class _TomwerObjectList(qt.QTableWidget):
             # in this case we will update the value. Because if the same identifier already exists at launch time
             # it will create two different objects that could be an issue.
             # this is better to have it unified
-            self.remove(self._myitems[identifier_as_str].data(qt.Qt.UserRole))
+            with block_signals(self):
+                self.remove(self._myitems[identifier_as_str].data(qt.Qt.UserRole))
 
         item = qt.QTableWidgetItem()
         item.setText(identifier_as_str)
@@ -677,6 +687,7 @@ class _TomwerObjectList(qt.QTableWidget):
         self.setRowCount(row + 1)
         self.setItem(row, 0, item)
         self._myitems[identifier_as_str] = item
+        self.listChanged.emit()
         return (obj,)
 
     def setMySelection(self, datasets: tuple):
@@ -699,16 +710,18 @@ class _TomwerObjectList(qt.QTableWidget):
     def dropEvent(self, event):
         if event.mimeData().hasFormat("text/uri-list"):
             added_scans = set()
-            for url in event.mimeData().urls():
-                new_scans = self.add(str(url.path()))
-                if new_scans is not None:
-                    for new_scan in new_scans:
-                        if not isinstance(new_scan, TomwerObject):
-                            raise ValueError(
-                                f"new_scan should be an instance of {TomwerObject} and not {type(new_scan)}"
-                            )
-                    added_scans.update(new_scans)
+            with block_signals(self):
+                for url in event.mimeData().urls():
+                    new_scans = self.add(str(url.path()))
+                    if new_scans is not None:
+                        for new_scan in new_scans:
+                            if not isinstance(new_scan, TomwerObject):
+                                raise ValueError(
+                                    f"new_scan should be an instance of {TomwerObject} and not {type(new_scan)}"
+                                )
+                        added_scans.update(new_scans)
             self.setMySelection(added_scans)
+            self.listChanged.emit()
 
     def supportedDropActions(self):
         """Inherited method to redefine supported drop actions."""
@@ -742,13 +755,24 @@ class _TomwerObjectList(qt.QTableWidget):
             return item.data(qt.Qt.UserRole)
 
     def contextMenuEvent(self, event):
-        self._target = self._datasetAt(event.pos())
-        if self._target is not None:
-            self.menu.exec_(event.globalPos())
+        self._copy_target = self._datasetAt(event.pos())
+        self._copyAction.setVisible(self._copy_target is not None)
+        self.menu.exec_(event.globalPos())
 
     def _copyRequested(self):
         clipboard = qt.QGuiApplication.clipboard()
-        clipboard.setText(str(self._target))
+        if isinstance(self._copy_target, TomwerObject):
+            clipboard.setText(self._copy_target.get_identifier().to_str())
+        else:
+            clipboard.setText(str(self._copy_target))
+
+    def _pasteRequested(self):
+        clipboard = qt.QGuiApplication.clipboard()
+        identifier = clipboard.text()
+        try:
+            self.add(identifier)
+        except Exception as e:
+            logger.error(f"Failed to add {identifier}. Error is {e}")
 
 
 class GenericScanList(_TomwerObjectList):
@@ -760,8 +784,12 @@ class GenericScanList(_TomwerObjectList):
         """
         some rules to return a TomwerObject from an object (probably a path) from children class
         """
+        return self.getScanObject(obj)
+
+    @staticmethod
+    def getScanObject(obj):
         if not isinstance(obj, str):
-            raise TypeError
+            raise TypeError(f"obj is an instance of {type(obj)} when {str} expected")
         try:
             scan_obj = ScanFactory.create_tomo_object_from_identifier(obj)
         except ValueError as e1:
@@ -913,29 +941,76 @@ class VolumeList(_TomwerObjectList):
     }
 
     def _getTomoObject(self, obj: str):
+        return self.getVolumeObject(obj=obj)
+
+    @staticmethod
+    def getVolumeObject(obj, warn=True):
+        """
+        get volume from identifier... even if not contained in the list of items (using factory)
+        """
         try:
             tomo_obj = VolumeFactory.create_tomo_object_from_identifier(obj)
         except Exception as e:
             try:
-                tomo_obj = guess_volumes(obj, scheme_to_vol=self.DEFAULT_SCHEME_TO_VOL)
+                tomo_obj = guess_volumes(
+                    obj, scheme_to_vol=VolumeList.DEFAULT_SCHEME_TO_VOL
+                )
             except Exception:
-                logger.warning(f"Unable to create a volume from {obj}. Error is {e}")
+                if warn:
+                    logger.warning(
+                        f"Unable to create a volume from {obj}. Error is {e}"
+                    )
                 return None
             else:
+                # filter potential 'nabu histogram'
+                if tomo_obj is not None:
+
+                    def is_not_histogram(vol_identifier):
+                        return not (
+                            hasattr(vol_identifier, "data_path")
+                            and vol_identifier.data_path.endswith("histogram")
+                        )
+
+                    tomo_obj = tuple(filter(is_not_histogram, tomo_obj))
+
                 if tomo_obj is None or len(tomo_obj) == 0:
                     logger.warning(f"Unable to create a volume from {obj}.")
                     return None
                 else:
                     if len(tomo_obj) > 1:
-                        logger.warning(
-                            f"more than one volume deduce from {obj}. Will only take the first one ({tomo_obj[0]})"
-                        )
+                        if warn:
+                            logger.warning(
+                                f"more than one volume deduce from {obj}. Will only take the first one ({tomo_obj[0]})"
+                            )
                     return tomo_obj[0]
         else:
             return tomo_obj
 
     def getVolume(self, volume_id: str, default=None):
+        """
+        get volume from id contained in the current items, else default
+        """
         if volume_id in self._myitems:
             return self._myitems[volume_id].data(qt.Qt.UserRole)
         else:
             return default
+
+
+class TomoObjList(_TomwerObjectList):
+    HEADER_NAMES = ("tomo object",)
+
+    def _getTomoObject(self, obj: str):
+        try:
+            tomo_obj = VolumeList.getVolumeObject(obj=obj)
+        except Exception:
+            pass
+        else:
+            if tomo_obj not in (None, tuple()):
+                return tomo_obj
+
+        try:
+            tomo_obj = GenericScanList.getScanObject(obj=obj)
+        except Exception:
+            return None
+        else:
+            return tomo_obj

tomwer/gui/control/datatransfert.py

@@ -111,7 +111,7 @@ class DataTransfertSelector(qt.QWidget):
         if b is True:
             self.__updateFolder(None)
 
-    def _changeFolder(self):
+    def _changeFolder(self):  # pragma: no cover
         """Callback when folder selection is choose"""
         defaultDirectory = self._folderSelection.text()
         if os.path.isdir(defaultDirectory):