tomwer 1.1.1__py3-none-any.whl → 1.2.0a0__py3-none-any.whl

tomwer/gui/control/datadiscovery.py

@@ -0,0 +1,168 @@
+from typing import Optional
+
+from silx.gui import qt
+
+from tomwer.core.scan.scantype import ScanType
+from tomwer.gui.control import datareacheractions
+from tomwer.gui.control.datawatcher.controlwidget import ControlWidget
+
+
+class ScanDiscoveryConfigWidget(qt.QGroupBox):
+    sigScanTypeChanged = qt.Signal()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setLayout(qt.QVBoxLayout())
+        self._nxtomoQRB = qt.QRadioButton(ScanType.NX_TOMO.value, parent=self)
+        self.layout().addWidget(self._nxtomoQRB)
+
+        self._blissQRB = qt.QRadioButton(ScanType.BLISS.value, parent=self)
+        self.layout().addWidget(self._blissQRB)
+
+        self._specQRB = qt.QRadioButton(ScanType.SPEC.value, parent=self)
+        self.layout().addWidget(self._specQRB)
+
+        # set up
+        self._nxtomoQRB.setChecked(True)
+        # connect signal / slot
+        self._nxtomoQRB.toggled.connect(self._configChanged)
+        self._blissQRB.toggled.connect(self._configChanged)
+        self._specQRB.toggled.connect(self._configChanged)
+
+    def _configChanged(self, *args, **kwargs):
+        self.sigScanTypeChanged.emit()
+
+    def getScanType(self) -> ScanType:
+        if self._specQRB.isChecked():
+            return ScanType.SPEC
+        elif self._blissQRB.isChecked():
+            return ScanType.BLISS
+        elif self._nxtomoQRB.isChecked():
+            return ScanType.NX_TOMO
+        else:
+            raise NotImplementedError
+
+    def setScanType(self, mode: ScanType):
+        mode = ScanType.from_value(mode)
+        if mode is ScanType.SPEC:
+            self._specQRB.setChecked(True)
+        elif mode is ScanType.BLISS:
+            self._blissQRB.setChecked(True)
+        elif mode is ScanType.NX_TOMO:
+            self._nxtomoQRB.setChecked(True)
+        else:
+            raise NotImplementedError
+
+
+class _MainWidget(qt.QWidget):
+    sigStart = qt.Signal()
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self.setLayout(qt.QVBoxLayout())
+        self.controlWidget = ControlWidget()
+        self.layout().addWidget(self.controlWidget)
+        self.configWidget = ScanDiscoveryConfigWidget(parent=self)
+        self.layout().addWidget(self.configWidget)
+
+        # set up
+        self.configWidget.setVisible(False)
+        self.controlWidget.setVisible(False)
+        self.controlWidget._qpbstartstop.setText("start discovery")
+        # connect signal / slot
+        self.controlWidget._qpbstartstop.released.connect(self._startDiscovery)
+        # expose api
+        self.sigScanTypeChanged = self.configWidget.sigScanTypeChanged
+
+    def getConfigWindow(self):
+        return self.configWidget
+
+    def _startDiscovery(self):
+        self.sigStart.emit()
+
+    def getFolderObserved(self):
+        return self.controlWidget._qteFolderSelected.text()
+
+    def setFolderObserved(self, dir_):
+        return self.controlWidget._qteFolderSelected.setText(dir_)
+
+    def getLinuxFilePattern(self) -> Optional[str]:
+        text = self.controlWidget._filterQLE.text()
+        if text.replace(" ", "") == "":
+            return None
+        else:
+            return text
+
+    def setLinuxFilePattern(self, pattern: Optional[str]):
+        if pattern is None:
+            pattern = ""
+        self.controlWidget._filterQLE.setText(pattern)
+
+    def setSearchScanType(self, scan_type):
+        self.configWidget.setScanType(scan_type)
+
+    def getSearchScqnType(self):
+        return self.configWidget.getScanType()
+
+
+class DataDiscoveryWidget(qt.QMainWindow):
+    sigTMStatusChanged = qt.Signal(str)
+    """Signal emitted when the state changed"""
+    sigScanReady = qt.Signal(object)
+    """Signal emitted when a scan is considered as ready"""
+    sigFolderObservedChanged = qt.Signal()
+    """Signal emitted when the user change the observed folder"""
+    sigObservationStart = qt.Signal()
+    """Signal emitted when the observation starts"""
+    sigObservationEnd = qt.Signal()
+    """Signal emitted when the observation end"""
+    sigFilterFileNamePatternChanged = qt.Signal(str)
+    """Signal emut when the filter pattern change"""
+
+    def __init__(self, parent=None, **kwargs) -> None:
+        super().__init__(parent, **kwargs)
+        self.setWindowFlags(qt.Qt.Widget)
+        self._mainWidget = _MainWidget(parent=self)
+        self.setCentralWidget(self.widget)
+        # create toolbar
+        toolbar = qt.QToolBar("", parent=self)
+        toolbar.setIconSize(qt.QSize(32, 32))
+        self._controlAction = datareacheractions.ControlAction(parent=self)
+        self._configurationAction = datareacheractions.ConfigurationAction(parent=self)
+        toolbar.addAction(self._controlAction)
+        toolbar.addAction(self._configurationAction)
+
+        self._actionGroup = qt.QActionGroup(self)
+        self._actionGroup.addAction(self._controlAction)
+        self._actionGroup.addAction(self._configurationAction)
+
+        self.addToolBar(qt.Qt.LeftToolBarArea, toolbar)
+        toolbar.setMovable(False)
+        # connect signal / slot
+        self._controlAction.toggled[bool].connect(
+            self._mainWidget.controlWidget.setVisible
+        )
+        self._configurationAction.toggled[bool].connect(
+            self._mainWidget.configWidget.setVisible
+        )
+        self._controlAction.setChecked(True)
+
+    def getConfiguration(self) -> dict:
+        return {
+            "start_folder": self.widget.getFolderObserved(),
+            "file_filter": self.widget.getLinuxFilePattern(),
+            "scan_type_searched": self.widget.getConfigWindow().getScanType().value,
+        }
+
+    def setConfiguration(self, config: dict):
+        if "start_folder" in config:
+            self.widget.setFolderObserved(config["start_folder"])
+        if "file_filter" in config:
+            self.widget.setLinuxFilePattern(config["file_filter"])
+        type_searched = config.get("scan_type_searched", None)
+        if type_searched is not None:
+            self.widget.getConfigWindow().setScanType(type_searched)
+
+    @property
+    def widget(self) -> qt.QWidget:
+        return self._mainWidget

tomwer/gui/control/datalist.py

@@ -30,42 +30,45 @@ __date__ = "12/07/2022"
 import logging
 import os
 from collections import OrderedDict
+from typing import Any, Optional, Union
+
+from nxtomomill import converter as nxtomomill_converter
+from nxtomomill.io import generate_default_edf_config, generate_default_h5_config
+from nxtomomill.io.config import TomoEDFConfig as EDFConfig
+from nxtomomill.io.config import TomoHDF5Config as HDF5Config
 from silx.gui import qt
 from tomoscan.esrf.identifier.edfidentifier import EDFVolumeIdentifier
 from tomoscan.esrf.identifier.hdf5Identifier import (
-    HDF5VolumeIdentifier,
     HDF5TomoScanIdentifier,
+    HDF5VolumeIdentifier,
 )
+from tomoscan.esrf.identifier.jp2kidentifier import JP2KVolumeIdentifier
+from tomoscan.esrf.identifier.rawidentifier import RawVolumeIdentifier
 from tomoscan.esrf.identifier.tiffidentifier import (
-    TIFFVolumeIdentifier,
     MultiTiffVolumeIdentifier,
+    TIFFVolumeIdentifier,
 )
-from tomoscan.esrf.identifier.jp2kidentifier import JP2KVolumeIdentifier
-from tomoscan.esrf.identifier.rawidentifier import RawVolumeIdentifier
+from tomoscan.esrf.volume.utils import guess_volumes
+from tomoscan.identifier import BaseIdentifier
+
+from tomwer.core.scan.blissscan import BlissScan
 from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.tomwer_object import TomwerObject
 from tomwer.core.volume.edfvolume import EDFVolume
 from tomwer.core.volume.hdf5volume import HDF5Volume
-from tomwer.core.volume.tiffvolume import MultiTIFFVolume, TIFFVolume
-from tomwer.core.volume.rawvolume import RawVolume
 from tomwer.core.volume.jp2kvolume import JP2KVolume
-from tomwer.gui.qfolderdialog import QDataDialog, QVolumeDialog
-from tomwer.gui.control.actions import NXTomomillParamsAction
-from tomwer.gui.control.actions import CFGFileActiveLabel
-from tomwer.gui.utils.inputwidget import EDFConfigFileSelector, HDF5ConfigFileSelector
-from tomwer.gui.utils.inputwidget import NXTomomillOutputDirSelector
+from tomwer.core.volume.rawvolume import RawVolume
+from tomwer.core.volume.tiffvolume import MultiTIFFVolume, TIFFVolume
 from tomwer.core.volume.volumefactory import VolumeFactory
-from tomoscan.esrf.volume.utils import guess_volumes
-from nxtomomill import converter as nxtomomill_converter
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.scan.blissscan import BlissScan
-from tomoscan.identifier import BaseIdentifier
-from typing import Any, Optional, Union
-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.control.actions import CFGFileActiveLabel, NXTomomillParamsAction
+from tomwer.gui.qfolderdialog import QDataDialog, QVolumeDialog
+from tomwer.gui.utils.inputwidget import (
+    EDFConfigFileSelector,
+    HDF5ConfigFileSelector,
+    NXTomomillOutputDirSelector,
+)
 from tomwer.gui.utils.qt_utils import block_signals
 
 logger = logging.getLogger(__name__)
@@ -851,17 +854,15 @@ class BlissScanList(_TomwerObjectList):
 
                 if HDF5TomoScan.is_nexus_nxtomo_file(data):
                     text = (
-                        "The input file `{}` seems to contain `NXTomo` entries. "
+                        f"The input file `{data}` seems to contain `NXTomo` entries. "
                         "and no valid `Bliss` valid entry. \n"
-                        "This is probably not a Bliss file. Do you still want to "
-                        "translate ?".format(data)
+                        "This is probably not a Bliss file. Do you still want to translate ?"
                     )
                 else:
                     text = (
-                        "The input file `{}` does not seems to contain any "
+                        f"The input file `{data}` does not seems to contain any "
                         "valid `Bliss` entry. \n"
-                        "This is probably not a Bliss file. Do you still want to "
-                        "translate ?".format(data)
+                        "This is probably not a Bliss file. Do you still want to translate ?"
                     )
                 msg.setText(text)
                 if msg.exec_() != qt.QMessageBox.Ok:
@@ -873,7 +874,7 @@ class BlissScanList(_TomwerObjectList):
                 ):
                     possible_entries.append(entry)
             except Exception:
-                logger.error("Faild to find entries for {}".format(data))
+                logger.error(f"Faild to find entries for {data}")
                 return
             else:
                 file_path = data

tomwer/gui/control/datalistener.py

@@ -29,19 +29,23 @@ __date__ = "16/03/2020"
 
 
 import os
-import weakref
 import socket
+import weakref
+
 from silx.gui import qt
+
 from tomwer.core import settings
 from tomwer.core.process.utils import LastReceivedScansDict
+from tomwer.core.scan.blissscan import BlissScan
 from tomwer.gui import icons as tomwericons
 from tomwer.gui.control import datareacheractions as actions
 from tomwer.gui.control.history import ScanHistory
 from tomwer.gui.control.observations import ScanObservation
-from tomwer.core.scan.blissscan import BlissScan
+from tomwer.gui.utils.inputwidget import (
+    HDF5ConfigFileSelector,
+    NXTomomillOutputDirSelector,
+)
 from tomwer.synctools.rsyncmanager import BlissSequenceRSyncWorker
-from tomwer.gui.utils.inputwidget import HDF5ConfigFileSelector
-from tomwer.gui.utils.inputwidget import NXTomomillOutputDirSelector
 
 
 class DataListenerWidget(qt.QMainWindow):

tomwer/gui/control/datareacheractions.py

@@ -28,9 +28,10 @@ __license__ = "MIT"
 __date__ = "18/02/2018"
 
 
-from tomwer.gui import icons as tomwericons
 from silx.gui import qt
 
+from tomwer.gui import icons as tomwericons
+
 
 class HistoryAction(qt.QAction):
     """

tomwer/gui/control/datatransfert.py

@@ -28,9 +28,11 @@ __license__ = "MIT"
 __date__ = "08/02/2019"
 
 
-from silx.gui import qt
 import logging
 import os
+
+from silx.gui import qt
+
 from tomwer.io.utils import get_default_directory
 
 _logger = logging.getLogger(__file__)

tomwer/gui/control/datavalidator.py

@@ -28,18 +28,19 @@ __license__ = "MIT"
 __date__ = "23/07/2020"
 
 
+import logging
+import time
+import weakref
+from contextlib import AbstractContextManager
+
 from silx.gui import qt
-from tomwer.gui.visualization.dataviewer import DataViewer
+
 from tomwer.core.process.control.scanvalidator import ScanValidator as BaseDataValidator
-from tomwer.gui.utils.waiterthread import QWaiterThread
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.scan.scanbase import _TomwerBaseDock
-from tomwer.gui.qfolderdialog import QDataDialog
+from tomwer.core.scan.scanbase import TomwerScanBase, _TomwerBaseDock
 from tomwer.core.scan.scanfactory import ScanFactory
-import weakref
-from contextlib import AbstractContextManager
-import logging
-import time
+from tomwer.gui.qfolderdialog import QDataDialog
+from tomwer.gui.utils.waiterthread import QWaiterThread
+from tomwer.gui.visualization.dataviewer import DataViewer
 
 _logger = logging.getLogger(__file__)
 
@@ -240,9 +241,7 @@ class DataValidator(qt.QMainWindow, BaseDataValidator):
                 scans = ScanFactory.create_scan_objects(scan_path=folder)
             except Exception as e:
                 _logger.error(
-                    "cannot create scan instances from {}. Error is {}".format(
-                        folder, e
-                    )
+                    f"cannot create scan instances from {folder}. Error is {e}"
                 )
             else:
                 for scan in scans:

tomwer/gui/control/datawatcher/configuration.py

@@ -29,10 +29,11 @@ __date__ = "18/02/2018"
 
 
 import functools
+
 from silx.gui import qt
 
-from tomwer.core.process.control.datawatcher.datawatcher import _DataWatcher
 from tomwer.core.process.control.datawatcher import status
+from tomwer.core.process.control.datawatcher.datawatcher import _DataWatcher
 
 
 class _DWConfigurationWidget(qt.QWidget):
@@ -157,6 +158,8 @@ class _SpecEDFObservationMethodSelector(qt.QGroupBox):
         self.layout().addWidget(self._qrbXml)
         self._qrbInfo = qt.QRadioButton(status.PARSE_INFO_FILE, parent=self)
         self.layout().addWidget(self._qrbInfo)
+        self._qrbAnyEDF = qt.QRadioButton(status.EDF_SCAN_END, parent=self)
+        self.layout().addWidget(self._qrbAnyEDF)
 
         self._qwUserEntry = qt.QWidget(parent=self)
         self.layout().addWidget(self._qwUserEntry)
@@ -188,10 +191,14 @@ class _SpecEDFObservationMethodSelector(qt.QGroupBox):
         spacer.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
         self.layout().addWidget(spacer)
 
+        # set up
+        self._qrbAnyEDF.hide()  # by default for the DataWatcher compatibility this one is hidded
+
         # deal with connections
         self._qrbUserEntry.toggled.connect(self.widgetFilePtrn.setVisible)
         self._qrbXml.toggled.connect(self._selectionChanged)
         self._qrbInfo.toggled.connect(self._selectionChanged)
+        self._qrbAnyEDF.toggled.connect(self._selectionChanged)
         self._qrbUserEntry.toggled.connect(self._selectionChanged)
         self._qleFilePattern.editingFinished.connect(self._selectionChanged)
 
@@ -223,6 +230,8 @@ class _SpecEDFObservationMethodSelector(qt.QGroupBox):
             return (status.DET_END_XML,)
         elif self._qrbInfo.isChecked():
             return (status.PARSE_INFO_FILE,)
+        elif self._qrbAnyEDF.isChecked():
+            return (status.EDF_SCAN_END,)
         elif self._qrbUserEntry.isChecked():
             return (status.DET_END_USER_ENTRY, {"pattern": self._qleFilePattern.text()})
         else:
@@ -233,6 +242,8 @@ class _SpecEDFObservationMethodSelector(qt.QGroupBox):
             self._qrbXml.setChecked(True)
         elif mode[0] == status.PARSE_INFO_FILE:
             self._qrbInfo.setChecked(True)
+        elif mode[0] == status.EDF_SCAN_END:
+            self._qrbAnyEDF.setChecked(True)
         elif mode[0] == status.DET_END_USER_ENTRY:
             self._qrbUserEntry.setChecked(True)
             if mode[1] not in (None, ""):

tomwer/gui/control/datawatcher/controlwidget.py

@@ -0,0 +1,116 @@
+import os
+from tomwer.gui.qlefilesystem import QLFileSystem
+from silx.gui import qt, icons as silxicons
+from tomwer.io.utils import get_default_directory
+
+
+class ControlWidget(qt.QWidget):
+    _TXT_STOP_OBS = "Stop observation"
+    _TXT_START_OBS = "Start observation"
+
+    def __init__(self, parent=None, **kwargs) -> None:
+        super().__init__(parent, **kwargs)
+        self.setLayout(qt.QVBoxLayout())
+        layout = self.layout()
+
+        self.mystatusBar = qt.QStatusBar(parent=self)
+        self._qlInfo = qt.QLabel(parent=self)
+
+        layout.addWidget(self._getFolderSelection())
+        layout.addWidget(self._qlInfo)
+        layout.addWidget(self._buildFilterWidget())
+        layout.addWidget(self._buildStartStopButton())
+        layout.addWidget(self.mystatusBar)
+
+        spacer = qt.QWidget(self)
+        spacer.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
+        layout.addWidget(spacer)
+
+    def _getFolderSelection(self):
+        """
+        Return the widget used for the folder selection
+        """
+        widget = qt.QWidget(self)
+        layout = qt.QHBoxLayout()
+
+        self._qtbSelectFolder = qt.QPushButton("Select folder", parent=widget)
+        self._qtbSelectFolder.setAutoDefault(True)
+        self._qtbSelectFolder.clicked.connect(self._setFolderPath)
+
+        self._qteFolderSelected = QLFileSystem("", parent=widget)
+
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        layout.addWidget(self._qteFolderSelected)
+        layout.addWidget(self._qtbSelectFolder)
+
+        self.animated_icon = silxicons.getWaitIcon()
+        self._stateLabel = qt.QLabel(parent=widget)
+        self.animated_icon.register(self._stateLabel)
+
+        self._stateLabel.setFixedWidth(30)
+        layout.addWidget(self._stateLabel)
+
+        widget.setLayout(layout)
+        return widget
+
+    def _buildFilterWidget(self):
+        widget = qt.QWidget(self)
+        layout = qt.QHBoxLayout()
+        widget.setLayout(layout)
+        widget.layout().addWidget(qt.QLabel("filter"))
+        self._filterQLE = qt.QLineEdit("", self)
+        self._filterQLE.setToolTip(
+            "You can provide a Linux Regular Expression that will insure only file fitting the expression will be discovered"
+        )
+        self._filterQLE.setPlaceholderText("*file_pattern*")
+        widget.layout().addWidget(self._filterQLE)
+
+        return widget
+
+    def _buildStartStopButton(self):
+        """
+        Build the start/stop button in a QHLayout with one spacer on the left
+        and one on the right
+        """
+        widget = qt.QWidget(self)
+        layout = qt.QHBoxLayout()
+        widget.setLayout(layout)
+
+        # left spacer
+        spacerL = qt.QWidget(widget)
+        spacerL.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Minimum)
+        layout.addWidget(spacerL)
+
+        # button
+        self._qpbstartstop = qt.QPushButton(self._TXT_START_OBS)
+        self._qpbstartstop.setAutoDefault(True)
+        layout.addWidget(self._qpbstartstop)
+
+        # right spacer
+        spacerR = qt.QWidget(widget)
+        spacerR.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Minimum)
+        layout.addWidget(spacerR)
+
+        return widget
+
+    def _setFolderPath(self):  # pragma: no cover
+        """
+        Ask the user the path to the folder to observe
+        """
+        defaultDirectory = self.getFolderObserved()
+        if defaultDirectory is None or not os.path.isdir(defaultDirectory):
+            if os.path.isdir(self.DEFAULT_DIRECTORY):
+                defaultDirectory = self.DEFAULT_DIRECTORY
+            if defaultDirectory is None:
+                defaultDirectory = get_default_directory()
+
+        dialog = qt.QFileDialog(self, directory=defaultDirectory)
+        dialog.setFileMode(qt.QFileDialog.DirectoryOnly)
+
+        if not dialog.exec_():
+            dialog.close()
+            return
+
+        self.setFolderObserved(dialog.selectedFiles()[0])