tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/gui/edit/test/test_dkrf_patch.py

@@ -37,11 +37,11 @@ from nxtomomill.utils import add_dark_flat_nx_file
 from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 from silx.io.url import DataUrl
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 from tomoscan.esrf.scan.utils import get_data
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.edit.dkrfpatch import DarkRefPatchWidget, _DarkOrFlatUrl
 from tomwer.tests.utils import skip_gui_test
 
@@ -62,13 +62,13 @@ class TestDarkOrFlatUrl(TestCaseQt):
         )
         self.output_folder = tempfile.mkdtemp()
         #
-        hdf5_mock = MockHDF5(
+        hdf5_mock = MockNXtomo(
             scan_path=self.output_folder,
             n_ini_proj=20,
             n_proj=20,
             create_ini_dark=True,
-            create_ini_ref=True,
-            create_final_ref=True,
+            create_ini_flat=True,
+            create_final_flat=True,
         )
         self._scan = hdf5_mock.scan
         self.scan_url = DataUrl(
@@ -130,23 +130,23 @@ class TestDarkRefPatchWidget(TestCaseQt):
         self.output_folder1 = tempfile.mkdtemp()
         self.output_folder2 = tempfile.mkdtemp()
 
-        hdf5_mock = MockHDF5(
+        hdf5_mock = MockNXtomo(
             scan_path=self.output_folder1,
             n_ini_proj=20,
             n_proj=20,
             create_ini_dark=True,
-            create_ini_ref=True,
-            create_final_ref=True,
+            create_ini_flat=True,
+            create_final_flat=True,
         )
         self._scanWithDarkAndRef = hdf5_mock.scan
 
-        hdf5_mock = MockHDF5(
+        hdf5_mock = MockNXtomo(
             scan_path=self.output_folder2,
             n_ini_proj=20,
             n_proj=20,
             create_ini_dark=False,
-            create_ini_ref=False,
-            create_final_ref=False,
+            create_ini_flat=False,
+            create_final_flat=False,
         )
         self._scan = hdf5_mock.scan
         assert len(self._scan.darks) == 0
@@ -176,7 +176,7 @@ class TestDarkRefPatchWidget(TestCaseQt):
         self.assertTrue(self._widget.getEndDarkUrl() is None)
         self.assertTrue(self._widget.getEndFlatUrl() is None)
         self.process()
-        new_scan = HDF5TomoScan(scan=self._scan.master_file, entry=self._scan.entry)
+        new_scan = NXtomoScan(scan=self._scan.master_file, entry=self._scan.entry)
         self.assertEqual(len(new_scan.darks), 1)
         self.assertTrue(0 in new_scan.darks)
         numpy.testing.assert_array_equal(

tomwer/gui/edit/test/test_image_key_editor.py

@@ -33,9 +33,9 @@ import tempfile
 import pytest
 from silx.gui import qt
 from silx.gui.utils.testutils import SignalListener, TestCaseQt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.edit.imagekeyeditor import (
     ImageKeyDialog,
     ImageKeyUpgraderWidget,
@@ -55,7 +55,7 @@ class TestImageKeyEditorGUI(TestCaseQt):
         self._widget = ImageKeyDialog(parent=None)
         self.output_folder = tempfile.mkdtemp()
 
-        hdf5_mock = MockHDF5(
+        hdf5_mock = MockNXtomo(
             scan_path=self.output_folder,
             n_ini_proj=20,
             n_proj=20,

tomwer/gui/edit/test/test_nx_editor.py

@@ -2,21 +2,28 @@ import os
 
 import numpy
 import pytest
-from nxtomomill.nexus.nxtomo import NXtomo
 from silx.gui import qt
-from tomoscan.esrf.scan.hdf5scan import ImageKey
-from tomoscan.scanbase import _FOV
-from tomoscan.unitsystem.energysystem import EnergySI
-from tomoscan.unitsystem.metricsystem import MetricSystem
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from pyunitsystem.energysystem import EnergySI
+from pyunitsystem.metricsystem import MetricSystem
+
+from nxtomo.application.nxtomo import NXtomo
+from nxtomo.nxobject.nxdetector import ImageKey, FOV
+from nxtomo.utils.transformation import (
+    build_matrix,
+    UDDetTransformation,
+    LRDetTransformation,
+)
+from nxtomo.nxobject.nxtransformations import NXtransformations
+
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui.edit.nxtomoeditor import NXtomoEditor, _TranslationMetricEntry
 from tomwer.tests.conftest import qtapp  # noqa F401
 
 
 @pytest.mark.parametrize("x_pixel_size", (None, 0.12))
 @pytest.mark.parametrize("y_pixel_size", (None, 0.0065))
-@pytest.mark.parametrize("field_of_view", _FOV.values())
+@pytest.mark.parametrize("field_of_view", FOV.values())
 @pytest.mark.parametrize("distance", (None, 1.2))
 @pytest.mark.parametrize("energy", (None, 23.5))
 @pytest.mark.parametrize("x_flipped", (True, False))
@@ -42,14 +49,20 @@ def test_nx_editor(
     nx_tomo.instrument.detector.y_pixel_size = y_pixel_size
     nx_tomo.instrument.detector.field_of_view = field_of_view
     nx_tomo.instrument.detector.distance = distance
-    nx_tomo.instrument.detector.x_flipped = x_flipped
-    nx_tomo.instrument.detector.y_flipped = y_flipped
     nx_tomo.energy = energy
     nx_tomo.sample.x_translation = x_translation
     nx_tomo.sample.z_translation = z_translation
     nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION.value] * 12
     nx_tomo.instrument.detector.data = numpy.empty(shape=(12, 10, 10))
     nx_tomo.sample.rotation_angle = numpy.linspace(0, 20, num=12)
+    if x_flipped:
+        nx_tomo.instrument.detector.transformations.add_transformation(
+            LRDetTransformation()
+        )
+    if y_flipped:
+        nx_tomo.instrument.detector.transformations.add_transformation(
+            UDDetTransformation()
+        )
 
     file_path = os.path.join(tmp_path, "nxtomo.nx")
     entry = "entry0000"
@@ -58,7 +71,7 @@ def test_nx_editor(
         data_path=entry,
     )
 
-    scan = HDF5TomoScan(file_path, entry)
+    scan = NXtomoScan(file_path, entry)
 
     # 2.0 create the widget and do the edition
     widget = NXtomoEditor()
@@ -107,7 +120,7 @@ def test_nx_editor(
     widget._xPixelSizeMetricEntry.setUnit("nm")
     widget._yPixelSizeMetricEntry.setValue(2.1e-7)
     widget._distanceMetricEntry.setValue("unknown")
-    widget._fieldOfViewCB.setCurrentText(_FOV.HALF.value)
+    widget._fieldOfViewCB.setCurrentText(FOV.HALF.value)
     widget._xFlippedCB.setChecked(not x_flipped)
     widget._xTranslationQLE.setValue(1.8)
     widget._xTranslationQLE.setUnit("mm")
@@ -135,10 +148,21 @@ def test_nx_editor(
     assert overwrite_nx_tomo.instrument.detector.y_pixel_size.value == 2.1e-7
 
     assert overwrite_nx_tomo.instrument.detector.distance.value is None
-    assert overwrite_nx_tomo.instrument.detector.field_of_view is _FOV.HALF
+    assert overwrite_nx_tomo.instrument.detector.field_of_view is FOV.HALF
 
-    assert overwrite_nx_tomo.instrument.detector.x_flipped is not x_flipped
-    assert overwrite_nx_tomo.instrument.detector.y_flipped is y_flipped
+    final_transformation = NXtransformations()
+
+    if y_flipped:
+        final_transformation.add_transformation(UDDetTransformation())
+    if not x_flipped:  # as we invert _xFlippedCB combobox
+        final_transformation.add_transformation(LRDetTransformation())
+
+    numpy.testing.assert_allclose(
+        build_matrix(
+            overwrite_nx_tomo.instrument.detector.transformations.transformations
+        ),
+        build_matrix(final_transformation.transformations),
+    )
 
     numpy.testing.assert_array_almost_equal(
         overwrite_nx_tomo.sample.x_translation.value,
@@ -181,7 +205,7 @@ def test_nx_editor_lock(
         data_path=entry,
     )
 
-    scan_1 = HDF5TomoScan(file_path, entry)
+    scan_1 = NXtomoScan(file_path, entry)
 
     nx_tomo_2 = NXtomo()
     nx_tomo_2.instrument.detector.x_pixel_size = 4.023
@@ -206,7 +230,7 @@ def test_nx_editor_lock(
         data_path=entry,
     )
 
-    scan_2 = HDF5TomoScan(file_path, entry)
+    scan_2 = NXtomoScan(file_path, entry)
 
     # 2.0 create the widget and do the edition
     widget = NXtomoEditor()

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)