Source code for ewoksfluo.gui.pick_scans_widget

from typing import Dict
from typing import List
from typing import Optional
from typing import Tuple
from typing import Union

from AnyQt import QtWidgets
from AnyQt.QtCore import Signal
from ewokscore import missing_data
from ewoksorange.gui.widgets.parameter_form import ParameterForm

from . import serialize
from .dynamic_tab_widget import DynamicTabWidget

FilesType = List[str]
ScanRangesType = List[Tuple[int, int]]
ExcludeScansType = List[List[int]]

NestedFilesType = List[FilesType]
NestedScanRangesType = List[ScanRangesType]
NestedExcludeScansType = List[ExcludeScansType]

ValueType = Union[FilesType, ScanRangesType, ExcludeScansType]
NestedValueType = Union[NestedFilesType, NestedScanRangesType, NestedExcludeScansType]




class PickScansFromFileWidget(QtWidgets.QWidget):
    """
    Select scans based on one file name, a scan number
    range and a list of scan numbers to exclude.
    """

    changed = Signal(QtWidgets.QWidget)

    def __init__(self, initial_values: Optional[dict] = None, parent=None):
        super().__init__(parent=parent)

        self.form = ParameterForm(parent=self)

        parameters = {
            "filename": {
                "label": "HDF5 filename",
                "value_for_type": "",
                "select": "file",
            },
            "scan_min": {
                "label": "Minimum scan to include",
                "value_for_type": 1,
            },
            "scan_max": {
                "label": "Maximum scan to include",
                "value_for_type": 1,
            },
            "exclude_scans": {
                "label": "List of scans to exclude",
                "value_for_type": "",
                "serialize": serialize.integers_serializer,
                "deserialize": serialize.integers_deserializer,
            },
        }
        defaults = {"scan_min": 1, "scan_max": 1, "exclude_scans": []}

        initial_values = initial_values or {}
        for name, kw in parameters.items():
            value = initial_values.get(
                name, defaults.get(name, missing_data.MISSING_DATA)
            )
            self.form.addParameter(
                name,
                value=value,
                value_change_callback=self._inputs_changed,
                **kw,
            )

    def _inputs_changed(self):
        self.changed.emit(self)



    def enable_form_parameters(self, dynamic_names: List[str]):
        ewoks_to_form = {
            "filenames": ["filename"],
            "scan_ranges": ["scan_min", "scan_max"],
            "exclude_scans": ["exclude_scans"],
        }
        for ewoks_name, form_names in ewoks_to_form.items():
            for pname in form_names:
                self.form.set_parameter_enabled(
                    pname,
                    ewoks_name not in dynamic_names,
                )




    def get_default_input_values(self) -> Dict[str, ValueType]:
        default_inputs = self.form.get_parameter_values()
        return default_inputs






class PickScansFromFilesWidget(DynamicTabWidget):
    """
    Select scans based on one file names and for each filename
    a scan number range and a list of scan numbers to exclude.
    """

    changed = Signal(QtWidgets.QWidget)

    def __init__(
        self,
        initial_values: Optional[Dict[str, ValueType]] = None,
        parent=None,
    ):
        super().__init__(
            create_widget=self._create_widget,
            initial_values=initial_values,
            tab_label="File {}",
            parent=parent,
        )

    def _initialize_tabs(self, initial_values: Optional[Dict[str, ValueType]]):
        initial_values = initial_values or {}
        filenames: FilesType = initial_values.get("filenames") or []
        scan_ranges: ScanRangesType = initial_values.get("scan_ranges") or []
        exclude_scans: ExcludeScansType = initial_values.get("exclude_scans") or []
        lst = list(zip(filenames, scan_ranges, exclude_scans))
        if lst:
            for filename, scan_range, _exclude_scans in lst:
                scan_min, scan_max = scan_range
                initial_tab_values = {
                    "filename": filename,
                    "scan_min": scan_min,
                    "scan_max": scan_max,
                    "exclude_scans": _exclude_scans,
                }
                self.add_tab(initial_values=initial_tab_values)
        else:
            self.add_tab()

    def _create_widget(
        self, initial_values: Optional[dict] = None
    ) -> PickScansFromFileWidget:
        widget = PickScansFromFileWidget(initial_values=initial_values)
        widget.changed.connect(self.changed.emit)
        return widget



    def enable_form_parameters(self, dynamic_names: List[str]):
        for tab in self.tabs:
            tab.enable_form_parameters(dynamic_names)




    def get_default_input_values(
        self,
    ) -> Dict[str, ValueType]:
        filenames: FilesType = []
        scan_ranges: ScanRangesType = []
        exclude_scans: ExcludeScansType = []

        for tab in self.tabs:
            values = tab.get_default_input_values()

            filenames.append(values["filename"])
            scan_ranges.append([values["scan_min"], values["scan_max"]])
            exclude_scans.append(values["exclude_scans"] or [])

        return {
            "filenames": filenames,
            "scan_ranges": scan_ranges,
            "exclude_scans": exclude_scans,
        }






class PickScanGroupsWidget(DynamicTabWidget):
    """
    Select several groups for scans, each group based an a list of filenames
    and for each filename a scan number range and a list of scan numbers to exclude.
    """

    changed = Signal(QtWidgets.QWidget)

    def __init__(
        self,
        initial_values: Optional[Dict[str, NestedValueType]] = None,
        parent=None,
    ):
        super().__init__(
            create_widget=self._create_widget,
            initial_values=initial_values,
            tab_label="Group {}",
            parent=parent,
        )

    def _initialize_tabs(self, initial_values: Optional[Dict[str, NestedValueType]]):
        initial_values = initial_values or {}
        filenames: NestedFilesType = initial_values.get("filenames") or []
        scan_ranges: NestedScanRangesType = initial_values.get("scan_ranges") or []
        exclude_scans: NestedExcludeScansType = (
            initial_values.get("exclude_scans") or []
        )
        lst = list(zip(filenames, scan_ranges, exclude_scans))
        if lst:
            for _filenames, _scan_ranges, _exclude_scans in lst:
                initial_tab_values = {
                    "filenames": _filenames,
                    "scan_ranges": _scan_ranges,
                    "exclude_scans": _exclude_scans,
                }
                self.add_tab(initial_values=initial_tab_values)
        else:
            self.add_tab()

    def _create_widget(
        self, initial_values: Optional[dict] = None
    ) -> PickScansFromFilesWidget:
        widget = PickScansFromFilesWidget(initial_values=initial_values)
        widget.changed.connect(self.changed.emit)
        widget.tab_added.connect(self.tab_added.emit)
        widget.tab_removed.connect(self.tab_removed.emit)
        return widget



    def enable_form_parameters(self, dynamic_names: List[str]):
        for tab in self.tabs:
            tab.enable_form_parameters(dynamic_names)




    def get_default_input_values(
        self,
    ) -> Dict[str, NestedValueType]:
        filenames: NestedFilesType = []
        scan_ranges: NestedScanRangesType = []
        exclude_scans: NestedExcludeScansType = []

        for tab in self.tabs:
            values = tab.get_default_input_values()

            filenames.append(values["filenames"])
            scan_ranges.append(values["scan_ranges"])
            exclude_scans.append(values["exclude_scans"])

        return {
            "filenames": filenames,
            "scan_ranges": scan_ranges,
            "exclude_scans": exclude_scans,
        }