tomwer 1.1.0rc7__py3-none-any.whl → 1.2.0a0__py3-none-any.whl

tomwer/core/volume/rawvolume.py

@@ -28,16 +28,16 @@ __license__ = "MIT"
 __date__ = "11/01/2023"
 
 
-from tomoscan.esrf.volume.rawvolume import RawVolume as _RawVolume
-from tomwer.core.volume.volumebase import TomwerVolumeBase
+from urllib.parse import urlparse
+
+from processview.core.dataset import Dataset, DatasetIdentifier
 from tomoscan.esrf.identifier.rawidentifier import (
     RawVolumeIdentifier as _RawVolumeIdentifier,
 )
-from processview.core.dataset import DatasetIdentifier, Dataset
-from urllib.parse import urlparse
-from tomoscan.esrf.identifier.url_utils import (
-    split_path,
-)
+from tomoscan.esrf.identifier.url_utils import split_path
+from tomoscan.esrf.volume.rawvolume import RawVolume as _RawVolume
+
+from tomwer.core.volume.volumebase import TomwerVolumeBase
 
 
 class RawVolumeIdentifier(_RawVolumeIdentifier, DatasetIdentifier):

tomwer/core/volume/tiffvolume.py

@@ -29,16 +29,18 @@ __date__ = "05/07/2022"
 
 
 import os
-from tomoscan.esrf.volume.tiffvolume import (
-    TIFFVolume as _TIFFVolume,
-    MultiTIFFVolume as _MultiTIFFVolume,
-)
-from tomwer.core.volume.volumebase import TomwerVolumeBase
+
+from processview.core.dataset import Dataset, DatasetIdentifier
 from tomoscan.esrf.identifier.tiffidentifier import (
     MultiTiffVolumeIdentifier as _MultiTiffVolumeIdentifier,
+)
+from tomoscan.esrf.identifier.tiffidentifier import (
     TIFFVolumeIdentifier as _TIFFVolumeIdentifier,
 )
-from processview.core.dataset import DatasetIdentifier, Dataset
+from tomoscan.esrf.volume.tiffvolume import MultiTIFFVolume as _MultiTIFFVolume
+from tomoscan.esrf.volume.tiffvolume import TIFFVolume as _TIFFVolume
+
+from tomwer.core.volume.volumebase import TomwerVolumeBase
 
 
 class TIFFVolumeIdentifier(_TIFFVolumeIdentifier, DatasetIdentifier):

tomwer/core/volume/volumebase.py

@@ -1,4 +1,5 @@
 import os
+
 from tomwer.core.tomwer_object import TomwerObject
 
 

tomwer/core/volume/volumefactory.py

@@ -28,34 +28,34 @@ __license__ = "MIT"
 __date__ = "13/07/2022"
 
 
-from typing import Optional
+import logging
+from typing import Optional, Union
 from urllib.parse import urlparse
-from typing import Union
-from tomoscan.factory import Factory as _oVolumeFactory
+
+from tomoscan import identifier as _identifier_mod
 from tomoscan.esrf.identifier.url_utils import split_path
+from tomoscan.factory import Factory as _oVolumeFactory
 from tomoscan.identifier import BaseIdentifier, ScanIdentifier, VolumeIdentifier
-from tomoscan import identifier as _identifier_mod
+
+from tomwer.core.scan.edfscan import EDFTomoScan, EDFTomoScanIdentifier
+from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.volume import (
+    EDFVolume,
+    HDF5Volume,
+    JP2KVolume,
+    MultiTIFFVolume,
+    RawVolume,
+    TIFFVolume,
+)
 from tomwer.core.volume.edfvolume import EDFVolumeIdentifier
-from tomwer.core.scan.edfscan import EDFTomoScanIdentifier
 from tomwer.core.volume.hdf5volume import HDF5VolumeIdentifier
 from tomwer.core.volume.jp2kvolume import JP2KVolumeIdentifier
+from tomwer.core.volume.rawvolume import RawVolumeIdentifier
 from tomwer.core.volume.tiffvolume import (
-    TIFFVolumeIdentifier,
     MultiTiffVolumeIdentifier,
+    TIFFVolumeIdentifier,
 )
-from tomwer.core.volume.rawvolume import RawVolumeIdentifier
-from tomwer.core.volume import (
-    HDF5Volume,
-    EDFVolume,
-    MultiTIFFVolume,
-    TIFFVolume,
-    JP2KVolume,
-    RawVolume,
-)
-from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.utils import docstring
-import logging
 
 _logger = logging.getLogger(__name__)
 

tomwer/gui/cluster/slurm.py

@@ -29,7 +29,9 @@ __date__ = "11/10/2021"
 
 
 from typing import Optional
+
 from silx.gui import qt
+
 from tomwer.core.settings import SlurmSettings
 
 

tomwer/gui/cluster/supervisor.py

@@ -28,10 +28,12 @@ __license__ = "MIT"
 __date__ = "14/10/2021"
 
 
+import functools
+from collections import OrderedDict
+
 from silx.gui import qt
+
 from tomwer.core.futureobject import FutureTomwerObject
-from collections import OrderedDict
-import functools
 
 
 class FutureTomwerScanObserverWidget(qt.QWidget):

tomwer/gui/cluster/test/test_cluster.py

@@ -27,12 +27,13 @@ __license__ = "MIT"
 __date__ = "19/10/2021"
 
 
-from tomwer.gui.reconstruction.nabu.slurm import SlurmSettingsWidget
-from tomwer.core.settings import SlurmSettings
-from silx.gui.utils.testutils import TestCaseQt
+import pytest
 from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.core.settings import SlurmSettings
+from tomwer.gui.reconstruction.nabu.slurm import SlurmSettingsWidget
 from tomwer.tests.utils import skip_gui_test
-import pytest
 
 
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")

tomwer/gui/cluster/test/test_supervisor.py

@@ -30,11 +30,13 @@ __date__ = "08/11/2021"
 import asyncio
 import os
 import shutil
+import tempfile
+
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
-import tempfile
-from tomwer.core.utils.scanutils import MockHDF5
+
 from tomwer.core.futureobject import FutureTomwerObject
+from tomwer.core.utils.scanutils import MockHDF5
 from tomwer.gui.cluster.supervisor import FutureTomwerScanObserverWidget
 
 

tomwer/gui/conditions/filter.py

@@ -33,12 +33,13 @@ __date__ = "19/07/2018"
 
 
 from silx.gui import qt
+
+from tomwer.core.process.conditions.filters import FileNameFilter
 from tomwer.gui import icons
 from tomwer.gui.utils.sandboxes import (
     RegularExpressionSandBox,
     RegularExpressionSandBoxDialog,
 )
-from tomwer.core.process.conditions.filters import FileNameFilter
 
 
 class FileNameFilterWidget(qt.QWidget):
@@ -126,14 +127,14 @@ class FileNameFilterWidget(qt.QWidget):
         mess.setModal(False)
         mess.show()
 
-    def setActiveFilter(self, filter):
+    def setActiveFilter(self, filter_):
         valid_fiters = ("regular expression", "unix file name pattern")
-        if filter not in valid_fiters:
+        if filter_ not in valid_fiters:
             raise ValueError(
-                f"filter is expected to be one of {valid_fiters}. Not {filter}"
+                f"filter is expected to be one of {valid_fiters}. Not {filter_}"
             )
-        self._sandBoxPB.setVisible(filter == "regular expression")
-        self._filterTypeCB.setCurrentText(filter)
+        self._sandBoxPB.setVisible(filter_ == "regular expression")
+        self._filterTypeCB.setCurrentText(filter_)
 
     def getActiveFilter(self):
         return self._filterTypeCB.currentText()

tomwer/gui/control/actions.py

@@ -29,6 +29,7 @@ __date__ = "23/03/2021"
 
 
 from silx.gui import qt
+
 from tomwer.gui import icons as tomwer_icons
 
 

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, ""):