tomwer 1.2.8__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

tomwer/gui/icat/createscreenshots.py

@@ -0,0 +1,80 @@
+from silx.gui import qt
+from typing import Optional
+
+
+class CreateRawDataScreenshotsWidget(qt.QWidget):
+    """
+    Widget to allow the user define the screenshot to make of the raw data
+    """
+
+    sigConfigChanged = qt.Signal()
+    """emit when the configuration change"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setLayout(qt.QFormLayout())
+        # projections
+        self._projectionsCB = qt.QCheckBox("raw projections each", self)
+        self._projectionsSB = qt.QSpinBox(parent)
+        self._projectionsSB.setSuffix("°")
+        self.layout().addRow(self._projectionsCB, self._projectionsSB)
+        # flat field
+        self._flatFieldCB = qt.QCheckBox("first raw flat")
+        self.layout().addRow(self._flatFieldCB)
+        # dark field
+        self._darkFieldCB = qt.QCheckBox("first raw dark")
+        self.layout().addRow(self._darkFieldCB)
+
+        # set up
+        self._projectionsCB.setChecked(True)
+        self._flatFieldCB.setChecked(True)
+        self._darkFieldCB.setChecked(True)
+
+        # connect signal / slot
+        self._projectionsCB.toggled.connect(self._changed)
+        self._projectionsSB.valueChanged.connect(self._changed)
+        self._projectionsSB.setRange(0, 360)
+        self._projectionsSB.setValue(90)
+        self._flatFieldCB.toggled.connect(self._changed)
+        self._darkFieldCB.toggled.connect(self._changed)
+
+    def _changed(self, *args, **kwargs):
+        self.sigConfigChanged.emit()
+
+    def getConfiguration(self) -> dict:
+        return {
+            "raw_projections_required": self._projectionsCB.isChecked(),
+            "raw_projections_each": self._projectionsSB.value(),
+            "raw_darks_required": self._darkFieldCB.isChecked(),
+            "raw_flats_required": self._flatFieldCB.isChecked(),
+        }
+
+    def setRawProjections(self, required: bool, each_proj: Optional[int]):
+        self._projectionsCB.setChecked(required)
+        if each_proj is not None:
+            self._projectionsSB.setValue(int(each_proj))
+
+    def setFlatFieldRequired(self, required: bool):
+        self._flatFieldCB.setChecked(required)
+
+    def setDarkFieldRequired(self, required: bool):
+        self._darkFieldCB.setChecked(required)
+
+    def setConfiguration(self, configuration: dict):
+        assert isinstance(configuration, dict)
+        # handle raw projections
+        raw_projections_required = configuration.get(
+            "raw_projections_required", self._projectionsCB.isChecked()
+        )
+        raw_projections_each = configuration.get("raw_projections_each", None)
+        self.setRawProjections(
+            required=raw_projections_required, each_proj=raw_projections_each
+        )
+        # handle flat field
+        flat_field_required = configuration.get("raw_flats_required", None)
+        if flat_field_required is not None:
+            self.setFlatFieldRequired(flat_field_required)
+        # handle flat field
+        dark_field_required = configuration.get("raw_darks_required", None)
+        if dark_field_required is not None:
+            self.setDarkFieldRequired(dark_field_required)

tomwer/gui/icat/gallery.py

@@ -0,0 +1,214 @@
+import os
+from silx.gui import qt
+from silx.utils.enum import Enum as _Enum
+from tomwer.core.process.icat.gallery import OutputFormat
+from tomwer.gui.qlefilesystem import QLFileSystem
+from tomwer.io.utils import get_default_directory
+from tomwer.core.utils.dictutils import concatenate_dict
+from tomwer.core.process.icat.gallery import Binning
+
+from .publish import PublishProcessedDataWidget
+
+
+class _GalleryOutputDir(qt.QGroupBox):
+    class OutputDirMode(_Enum):
+        DATASET_GALLERY = "dataset gallery"
+        PROPOSAL_GALLERY = "proposal GALLERY"
+        CUSTOM = "custom"
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setLayout(qt.QGridLayout())
+        # dataset gallery option
+        self._datasetGalleryQRB = qt.QRadioButton(
+            self.OutputDirMode.DATASET_GALLERY.value, self
+        )
+        self.layout().addWidget(self._datasetGalleryQRB, 0, 0, 1, 4)
+        # proposal gallery option
+        self._proposalGalleryQRB = qt.QRadioButton(
+            self.OutputDirMode.PROPOSAL_GALLERY.value, self
+        )
+        self.layout().addWidget(self._proposalGalleryQRB, 1, 0, 1, 4)
+
+        # other option
+        self._otherQRB = qt.QRadioButton(self.OutputDirMode.CUSTOM.value, self)
+        self._otherQRB.setCheckable(True)
+        self.layout().addWidget(self._otherQRB, 2, 0, 1, 4)
+
+        self._otherQLE = QLFileSystem(
+            "", self, filters=qt.QDir.NoDotAndDotDot | qt.QDir.Dirs
+        )
+        self.layout().addWidget(self._otherQLE, 3, 1, 1, 2)
+        style = qt.QApplication.style()
+        icon_opendir = style.standardIcon(qt.QStyle.SP_DirOpenIcon)
+        self._selectOtherQLE = qt.QPushButton(icon_opendir, "", self)
+        self._selectOtherQLE.setIcon(icon_opendir)
+        self.layout().addWidget(self._selectOtherQLE, 3, 3, 1, 1)
+
+        # button group
+        self._buttonGroup = qt.QButtonGroup()
+        self._buttonGroup.setExclusive(True)
+        self._buttonGroup.addButton(self._datasetGalleryQRB)
+        self._buttonGroup.addButton(self._proposalGalleryQRB)
+        self._buttonGroup.addButton(self._otherQRB)
+
+        # vertical spacer
+        self._vSpacer = qt.QWidget(self)
+        self._vSpacer.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.Expanding)
+        self.layout().addWidget(self._vSpacer, 99, 0, 1, 1)
+
+        # set up GUI
+        self._datasetGalleryQRB.setChecked(True)
+        self._modeChanged()
+
+        # connect signal / slot
+        self._buttonGroup.buttonClicked.connect(self._modeChanged)
+        self._selectOtherQLE.released.connect(self._selectOutput)
+
+    def _selectOutput(self):  # pragma: no cover
+        defaultDirectory = self._selectOtherQLE.text()
+        if not os.path.isdir(defaultDirectory):
+            defaultDirectory = get_default_directory()
+
+        dialog = qt.QFileDialog(self, directory=defaultDirectory)
+        dialog.setFileMode(qt.QFileDialog.DirectoryOnly)
+
+        if not dialog.exec_():
+            dialog.close()
+            return
+
+        self._selectOtherQLE.setText(dialog.selectedFiles()[0])
+
+    def getOutputFolderMode(self):
+        if self._datasetGalleryQRB.isChecked():
+            return _GalleryOutputDir.OutputDirMode.DATASET_GALLERY
+        elif self._proposalGalleryQRB.isChecked():
+            return _GalleryOutputDir.OutputDirMode.PROPOSAL_GALLERY
+        elif self._otherQRB.isChecked():
+            return _GalleryOutputDir.OutputDirMode.CUSTOM
+        else:
+            raise NotImplementedError
+
+    def setOutputFolderMode(self, mode):
+        mode = _GalleryOutputDir.OutputDirMode.from_value(mode)
+        if mode is _GalleryOutputDir.OutputDirMode.PROPOSAL_GALLERY:
+            self._proposalGalleryQRB.setChecked(True)
+        elif mode is _GalleryOutputDir.OutputDirMode.DATASET_GALLERY:
+            self._datasetGalleryQRB.setChecked(True)
+        elif mode is _GalleryOutputDir.OutputDirMode.CUSTOM:
+            self._otherQRB.setChecked(True)
+        else:
+            raise NotImplementedError
+        self._modeChanged()
+
+    def getOtherOutputDir(self):
+        return self._otherQLE.text()
+
+    def setOtherOutputDir(self, path: str):
+        self._otherQLE.setText(path)
+
+    def _modeChanged(self, *args, **kwargs):
+        custom_active = self._otherQRB.isChecked()
+        self._otherQLE.setEnabled(custom_active)
+        self._selectOtherQLE.setEnabled(custom_active)
+
+
+class GalleryWidget(qt.QWidget):
+    """Widget to let the user define the output location of the screenshots"""
+
+    sigConfigChanged = qt.Signal()
+    """emit when the configuration has changed"""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setLayout(qt.QFormLayout())
+
+        # screenshot precision
+        self._precisonQCB = qt.QComboBox(self)
+        self._precisonQCB.addItem("uint8")
+        self.layout().addRow("precision", self._precisonQCB)
+        # binning
+        self._binningQCB = qt.QComboBox(self)
+        self._binningQCB.addItems(Binning.values())
+        self.layout().addRow("binning", self._binningQCB)
+        self._binningQCB.setCurrentText(Binning.SIXTEEN_BY_SIXTEEN.value)
+        self._binningQCB.setToolTip(
+            "To speed up display of the gallery at the data portal side it is highly recommended to bin screenshots"
+        )  # recommanded size: 5ko for the entire gallery
+        # output format
+        self._outputFormat = qt.QComboBox(self)
+        self._outputFormat.addItems(OutputFormat.values())
+        self.layout().addRow("outoutput_location_modeput format", self._outputFormat)
+        # gallery output dir
+        self._outputDirWidget = _GalleryOutputDir(self)
+        self._outputLocationLabel = qt.QLabel("output location", self)
+        self.layout().addRow(self._outputLocationLabel, self._outputDirWidget)
+        self._outputDirWidget.hide()
+        self._outputLocationLabel.hide()
+        # overwrite
+        self._overwriteCB = qt.QCheckBox("overwrite", self)
+        self._overwriteCB.setChecked(True)
+        self.layout().addRow(self._overwriteCB)
+        # publishing setting
+        self._publishConfig = PublishProcessedDataWidget(self)
+        self._publisherGB = qt.QGroupBox("icat info")
+        self._publisherGB.setLayout(qt.QVBoxLayout())
+        self._publisherGB.layout().addWidget(self._publishConfig)
+        self.layout().addRow(self._publisherGB)
+        # connect signal / slot
+        self._outputFormat.currentIndexChanged.connect(self._configChanged)
+        self._overwriteCB.toggled.connect(self._configChanged)
+        self._publishConfig.sigConfigChanged.connect(self.sigConfigChanged)
+        self._binningQCB.currentIndexChanged.connect(self._configChanged)
+
+    def getOutputFormat(self) -> OutputFormat:
+        return OutputFormat.from_value(self._outputFormat.currentText())
+
+    def setOutputFormat(self, format: OutputFormat):
+        format = OutputFormat.from_value(format)
+        self._outputFormat.setCurrentText(format.value)
+
+    def getBinning(self) -> Binning:
+        return Binning.from_value(self._binningQCB.currentText())
+
+    def setBinning(self, binning: Binning):
+        binning = Binning.from_value(binning)
+        self._binningQCB.setCurrentText(binning.value)
+
+    def getConfiguration(self):
+        return concatenate_dict(
+            self._publishConfig.getConfiguration(),
+            {
+                "output_format": self.getOutputFormat().value,
+                "output_location_mode": self._outputDirWidget.getOutputFolderMode().value,
+                "custom_output": self._outputDirWidget.getOtherOutputDir(),
+                "overwrite": self._overwriteCB.isChecked(),
+                "binning": self.getBinning().value,
+            },
+        )
+
+    def setConfiguration(self, config: dict):
+        self._publishConfig.setConfiguration(config)
+        output_format = config.get("output_format", None)
+        if output_format is not None:
+            self.setOutputFormat(output_format)
+
+        output_location_mode = config.get("output_location_mode", None)
+        if output_location_mode is not None:
+            self._outputDirWidget.setOutputFolderMode(output_location_mode)
+
+        custom_output = config.get("custom_output", None)
+        if custom_output is not None:
+            self._outputDirWidget.setOtherOutputDir(custom_output)
+
+        overwrite = config.get("overwrite", None)
+        if overwrite is not None:
+            overwrite = overwrite in (True, "True", 1)
+            self._overwriteCB.setChecked(overwrite)
+
+        binning = config.get("binning", None)
+        if binning is not None:
+            self.setBinning(binning=binning)
+
+    def _configChanged(self, *args, **kwargs):
+        self.sigConfigChanged.emit()

tomwer/gui/icat/publish.py

@@ -0,0 +1,187 @@
+import platform
+from silx.gui import qt
+from tomwer.core.scan.scanbase import TomwerScanBase
+from tomwer.gui.utils.qt_utils import block_signals
+from tomwer.gui.utils.buttons import PadlockButton
+
+
+class PublishProcessedDataWidget(qt.QWidget):
+    sigConfigChanged = qt.Signal()
+    """emit when the configuration changed"""
+
+    KNOW_BEAMLINES = sorted(
+        ("bm05", "bm18", "id11", "id15a", "id16a", "id16b", "id17", "id19")
+    )
+
+    _TOOLTIP_PAD_LOCKS = "when receive a new scan the value will be updated if valid informations are found. If the field is lock then no update will be done automatically."
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self.setLayout(qt.QGridLayout())
+
+        # beamline
+        self._beamlineCB = qt.QComboBox(self)
+        self._beamlineCB.setEditable(True)
+        self._beamlineCB.addItems(self.KNOW_BEAMLINES)
+        self._beamlineCB.lineEdit().setPlaceholderText("beamline name")
+        self.layout().addWidget(
+            qt.QLabel("beamline", self),
+            0,
+            0,
+            1,
+            1,
+        )
+        self.layout().addWidget(
+            self._beamlineCB,
+            0,
+            1,
+            1,
+            1,
+        )
+        self._beamlinePLB = PadlockButton(self)
+        self._beamlinePLB.setToolTip(self._TOOLTIP_PAD_LOCKS)
+        self.layout().addWidget(
+            self._beamlinePLB,
+            0,
+            2,
+            1,
+            1,
+        )
+
+        # proposal
+        self._proposalQLE = qt.QLineEdit("", self)
+        self._proposalQLE.setPlaceholderText("proposal name")
+        self.layout().addWidget(
+            qt.QLabel("proposal", self),
+            1,
+            0,
+            1,
+            1,
+        )
+        self.layout().addWidget(
+            self._proposalQLE,
+            1,
+            1,
+            1,
+            1,
+        )
+        self._proposalPLB = PadlockButton(self)
+        self._proposalPLB.setToolTip(self._TOOLTIP_PAD_LOCKS)
+        self.layout().addWidget(
+            self._proposalPLB,
+            1,
+            2,
+            1,
+            1,
+        )
+
+        # dataset
+        self._datasetQLE = qt.QLineEdit("", self)
+        self._datasetQLE.setPlaceholderText("dataset name")
+        self.layout().addWidget(
+            qt.QLabel("dataset", self),
+            2,
+            0,
+            1,
+            1,
+        )
+        self.layout().addWidget(
+            self._datasetQLE,
+            2,
+            1,
+            1,
+            1,
+        )
+        self._datasetPLB = PadlockButton(self)
+        self._datasetPLB.setToolTip(self._TOOLTIP_PAD_LOCKS)
+        self.layout().addWidget(
+            self._datasetPLB,
+            2,
+            2,
+            1,
+            1,
+        )
+
+        # set up
+        default_beamline = self.getDefaultBeamline()
+        if default_beamline is not None:
+            self._beamlineCB.setCurrentText(default_beamline)
+
+        # connect signal / slot
+        self._beamlinePLB.toggled.connect(self._configChanged)
+        self._proposalPLB.toggled.connect(self._configChanged)
+        self._datasetPLB.toggled.connect(self._configChanged)
+        self._beamlineCB.currentTextChanged.connect(self._configChanged)
+        self._proposalQLE.textEdited.connect(self._configChanged)
+        self._datasetQLE.textEdited.connect(self._configChanged)
+
+    @staticmethod
+    def getDefaultBeamline():
+        hostname = platform.node()
+        for beamline in PublishProcessedDataWidget.KNOW_BEAMLINES:
+            if beamline in hostname:
+                return beamline
+
+        return None
+
+    def set_auto_update(self, update: bool):
+        self._beamlinePLB.setChecked(not update)
+        self._proposalPLB.setChecked(not update)
+        self._datasetPLB.setChecked(not update)
+
+    def _configChanged(self, *args, **kwargs):
+        self.sigConfigChanged.emit()
+
+    def getConfiguration(self) -> dict:
+        return {
+            "beamline_auto_update": not self._beamlinePLB.isChecked(),
+            "dataset_auto_update": not self._datasetPLB.isChecked(),
+            "proposal_auto_update": not self._proposalPLB.isChecked(),
+            "beamline": self._beamlineCB.currentText(),
+            "dataset": self._datasetQLE.text(),
+            "proposal": self._proposalQLE.text(),
+        }
+
+    def setConfiguration(self, configuration: dict):
+        with block_signals(self):
+            # handle beamline
+            beamline = configuration.get("beamline", None)
+            if beamline is not None:
+                self._beamlineCB.setCurrentText(beamline)
+            beamline_auto_update = configuration.get("beamline_auto_update", None)
+            if beamline_auto_update is not None:
+                self._beamlinePLB.setChecked(not beamline_auto_update)
+
+            # handle dataset
+            dataset = configuration.get("dataset", None)
+            if dataset is not None:
+                self._datasetQLE.setText(dataset)
+            dataset_auto_update = configuration.get("dataset_auto_update", None)
+            if dataset_auto_update is not None:
+                self._datasetPLB.setChecked(not dataset_auto_update)
+
+            # handle proposal
+            proposal = configuration.get("proposal", None)
+            if proposal is not None:
+                self._proposalQLE.setText(proposal)
+            proposal_auto_update = configuration.get("proposal_auto_update", None)
+            if proposal_auto_update is not None:
+                self._proposalPLB.setChecked(not proposal_auto_update)
+
+        self._configChanged()
+
+    def setScan(self, scan: TomwerScanBase):
+        if not isinstance(scan, TomwerScanBase):
+            raise TypeError(
+                f"scan is expected to be an instance of {TomwerScanBase}, {type(scan)} provided instead"
+            )
+
+        new_config = {}
+        if not self._proposalPLB.isChecked():
+            new_config["proposal"] = scan.get_proposal_name()
+        if not self._beamlinePLB.isChecked():
+            new_config["beamline"] = scan.instrument_name
+        if not self._datasetPLB.isChecked():
+            new_config["dataset"] = scan.sample_name
+
+        self.setConfiguration(new_config)