essreduce 24.11.3__tar.gz → 24.12.0__tar.gz

{essreduce-24.11.3/src/essreduce.egg-info → essreduce-24.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: essreduce
-Version: 24.11.3
+Version: 24.12.0
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License

{essreduce-24.11.3 → essreduce-24.12.0}/docs/api-reference/index.md

@@ -30,6 +30,7 @@
    logging
    nexus
    streaming
+   ui
    uncertainty
    widgets
 ```

{essreduce-24.11.3 → essreduce-24.12.0}/pyproject.toml

@@ -68,6 +68,7 @@ addopts = """
 testpaths = "tests"
 filterwarnings = [
   "error",
+  'ignore:\n            Sentinel is not a public part of the traitlets API:DeprecationWarning',
 ]
 
 [tool.ruff]

{essreduce-24.11.3 → essreduce-24.12.0}/requirements/base.txt

@@ -50,7 +50,7 @@ python-dateutil==2.9.0.post0
     #   scippnexus
 sciline==24.10.0
     # via -r base.in
-scipp==24.11.1
+scipp==24.11.2
     # via
     #   -r base.in
     #   scippneutron

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/live/raw.py

@@ -285,7 +285,9 @@ class RollingDetectorView(Detector):
         wf[RollingDetectorViewWindow] = window
         if isinstance(projection, LogicalView):
             wf[LogicalView] = projection
-            wf[NeXusTransformation[snx.NXdetector, SampleRun]] = sc.scalar(1)
+            wf[NeXusTransformation[snx.NXdetector, SampleRun]] = NeXusTransformation[
+                snx.NXdetector, SampleRun
+            ](sc.scalar(1))
             wf.insert(RollingDetectorView.from_detector_and_logical_view)
         elif projection == 'cylinder_mantle_z':
             wf.insert(make_cylinder_mantle_coords)

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/nexus/types.py

@@ -78,7 +78,17 @@ RunType = TypeVar(
     TransmissionRun[BackgroundRun],
     VanadiumRun,
 )
-"""TypeVar used for specifying BackgroundRun, EmptyBeamRun or SampleRun"""
+"""TypeVar for specifying what run some data belongs to.
+
+Possible values:
+
+- :class:`BackgroundRun`
+- :class:`EmptyBeamRun`
+- :class:`SampleRun`
+- :class:`TransmissionRun`
+- :class:`VanadiumRun`
+"""
+
 
 # 1.2  Monitor types
 Monitor1 = NewType('Monitor1', int)
@@ -108,7 +118,20 @@ MonitorType = TypeVar(
     IncidentMonitor,
     TransmissionMonitor,
 )
-"""TypeVar used for specifying the monitor type such as Incident or Transmission"""
+"""TypeVar for specifying what monitor some data belongs to.
+
+Possible values:
+
+- :class:`Monitor1`
+- :class:`Monitor2`
+- :class:`Monitor3`
+- :class:`Monitor4`
+- :class:`Monitor5`
+- :class:`Monitor6`
+- :class:`IncidentMonitor`
+- :class:`TransmissionMonitor`
+"""
+
 
 Component = TypeVar(
     'Component',

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/nexus/workflow.py

@@ -3,12 +3,12 @@
 
 """Workflow and workflow components for interacting with NeXus files."""
 
-from collections.abc import Sequence
+from collections.abc import Iterable
 from copy import deepcopy
 from typing import Any
 
-import networkx as nx
 import sciline
+import sciline.typing
 import scipp as sc
 import scippnexus as snx
 from scipp.constants import g
@@ -649,30 +649,39 @@ def LoadDetectorWorkflow() -> sciline.Pipeline:
 
 def GenericNeXusWorkflow(
     *,
-    run_types: Sequence[sciline.typing.Key] | None = None,
-    monitor_types: Sequence[sciline.typing.Key] | None = None,
+    run_types: Iterable[sciline.typing.Key] | None = None,
+    monitor_types: Iterable[sciline.typing.Key] | None = None,
 ) -> sciline.Pipeline:
     """
     Generic workflow for loading detector and monitor data from a NeXus file.
 
+    It is possible to limit which run types and monitor types
+    are supported by the returned workflow.
+    This is useful to reduce the size of the workflow and make it easier to inspect.
+    Make sure to add *all* required run types and monitor types when using this feature.
+
+    Attention
+    ---------
+    Filtering by run type and monitor type does not work with nested type vars.
+    E.g., if you have a type like ``Outer[Inner[RunType]]``, this type and its
+    provider will be removed.
+
     Parameters
     ----------
     run_types:
         List of run types to include in the workflow. If not provided, all run types
-        are included. It is recommended to specify run types to avoid creating very
-        large workflows.
+        are included.
+        Must be a possible value of :class:`ess.reduce.nexus.types.RunType`.
     monitor_types:
         List of monitor types to include in the workflow. If not provided, all monitor
-        types are included. It is recommended to specify monitor types to avoid creating
-        very large workflows.
+        types are included.
+        Must be a possible value of :class:`ess.reduce.nexus.types.MonitorType`.
 
     Returns
     -------
     :
         The workflow.
     """
-    if monitor_types is not None and run_types is None:
-        raise ValueError("run_types must be specified if monitor_types is specified")
     wf = sciline.Pipeline(
         (
             *_common_providers,
@@ -685,16 +694,34 @@ def GenericNeXusWorkflow(
     wf[DetectorBankSizes] = DetectorBankSizes({})
     wf[PreopenNeXusFile] = PreopenNeXusFile(False)
 
-    g = wf.underlying_graph
-    ancestors = set()
-    # DetectorData and MonitorData are the "final" outputs, so finding and removing all
-    # their ancestors is what we need to strip unused run and monitor types.
-    for rt in run_types or ():
-        ancestors |= nx.ancestors(g, DetectorData[rt])
-        ancestors.add(DetectorData[rt])
-        for mt in monitor_types or ():
-            ancestors |= nx.ancestors(g, MonitorData[rt, mt])
-            ancestors.add(MonitorData[rt, mt])
-    if run_types is not None:
-        g.remove_nodes_from(set(g.nodes) - ancestors)
+    if run_types is not None or monitor_types is not None:
+        _prune_type_vars(wf, run_types=run_types, monitor_types=monitor_types)
+
     return wf
+
+
+def _prune_type_vars(
+    workflow: sciline.Pipeline,
+    *,
+    run_types: Iterable[sciline.typing.Key] | None,
+    monitor_types: Iterable[sciline.typing.Key] | None,
+) -> None:
+    # Remove all nodes that use a run type or monitor types that is
+    # not listed in the function arguments.
+    excluded_run_types = _excluded_type_args(RunType, run_types)
+    excluded_monitor_types = _excluded_type_args(MonitorType, monitor_types)
+    excluded_types = excluded_run_types | excluded_monitor_types
+
+    graph = workflow.underlying_graph
+    to_remove = [
+        node for node in graph if excluded_types & set(getattr(node, "__args__", set()))
+    ]
+    graph.remove_nodes_from(to_remove)
+
+
+def _excluded_type_args(
+    type_var: Any, keep: Iterable[sciline.typing.Key] | None
+) -> set[sciline.typing.Key]:
+    if keep is None:
+        return set()
+    return set(type_var.__constraints__) - set(keep)

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/parameter.py

@@ -71,7 +71,12 @@ class ParamWithOptions(Parameter[T]):
 
     @classmethod
     def from_enum(cls: type[C], t: type[T], default: T) -> C:
-        return cls(name=str(t), description=t.__doc__, options=t, default=default)
+        return cls(
+            name=t.__name__,
+            description=t.__doc__,
+            options=t.__members__,
+            default=default,
+        )
 
 
 @dataclass

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/ui.py

@@ -10,6 +10,7 @@ from ipywidgets import Layout
 
 from .parameter import Parameter
 from .widgets import SwitchWidget, create_parameter_widget, default_layout
+from .widgets._base import get_fields, set_fields
 from .workflow import (
     Key,
     assign_parameter_values,
@@ -81,11 +82,13 @@ class ParameterBox(widgets.VBox):
             self._input_widgets.clear()
             self._input_widgets.update(
                 {
-                    node: widgets.HBox([create_parameter_widget(parameter)])
-                    for node, parameter in registry_getter().items()
+                    node: create_parameter_widget(parameter)
+                    for node, parameter in new_input_parameters.items()
                 }
             )
-            self._input_box.children = list(self._input_widgets.values())
+            self._input_box.children = [
+                widgets.HBox([widget]) for widget in self._input_widgets.values()
+            ]
 
         self.parameter_refresh_button.on_click(_refresh_input_box)
 
@@ -97,8 +100,7 @@ class ParameterBox(widgets.VBox):
         return {
             node: widget.value
             for node, widget_box in self._input_widgets.items()
-            if (not isinstance((widget := widget_box.children[0]), SwitchWidget))
-            or widget.enabled
+            if (not isinstance((widget := widget_box), SwitchWidget)) or widget.enabled
         }
 
 
@@ -130,7 +132,7 @@ class ResultBox(widgets.VBox):
                     result_registry.clear()
                     result_registry.update(compute_result)
                 for i in compute_result.values():
-                    display.display(display.HTML(i._repr_html_()))
+                    display.display(i)
 
         def clear_output(_: widgets.Button) -> None:
             self.output.clear_output()
@@ -232,3 +234,82 @@ def workflow_widget(result_registry: dict | None = None) -> widgets.Widget:
     workflow_selection_box = widgets.HBox([workflow_select], layout=default_layout)
     workflow_box = widgets.Box(layout=default_layout)
     return widgets.VBox([workflow_selection_box, workflow_box])
+
+
+def _get_parameter_box(widget: WorkflowWidget | ParameterBox) -> ParameterBox:
+    if isinstance(widget, WorkflowWidget):
+        return widget.parameter_box
+    elif isinstance(widget, ParameterBox):
+        return widget
+    else:
+        raise TypeError(
+            f"Expected target_widget to be a WorkflowWidget or ParameterBox, "
+            f"got {type(widget)}."
+        )
+
+
+def set_parameter_widget_values(
+    widget: WorkflowWidget | ParameterBox, new_parameter_values: dict[type, Any]
+) -> None:
+    """Set the values of the input widgets in the target widget.
+
+    Nodes that don't exist in the input widgets will be ignored.
+
+    Example
+    -------
+    .. code-block::
+
+        set_parameter_widget_values(widget, {
+            'WavelengthBins': {'start': 1.0, 'stop': 14.0, 'nbins': 500}
+        })
+
+    Parameters
+    ----------
+    widget:
+        The widget containing the input widgets.
+    new_parameter_values:
+        A dictionary of values/state to set each fields/state or value of input widgets.
+
+    Raises
+    ------
+    TypeError:
+        If the widget is not a WorkflowWidget or a ParameterBox.
+
+    """
+    parameter_box = _get_parameter_box(widget)
+    # Walk through the existing input widgets and set the values
+    # ``node`s that don't exist in the input widgets will be ignored.
+    for node, widget in parameter_box._input_widgets.items():
+        if node in new_parameter_values:
+            # We shouldn't use `get` here because ``None`` is a valid value.
+            set_fields(widget, new_parameter_values[node])
+
+
+def get_parameter_widget_values(
+    widget: WorkflowWidget | ParameterBox,
+) -> dict[type, Any]:
+    """Return the current values of the input widgets in the target widget.
+
+    The result of this function can be used to set the values of the input widgets
+    using the :py:func:`~set_parameter_widget_values` function.
+
+    Parameters
+    ----------
+    widget:
+        The widget containing the input widgets.
+
+    Returns
+    -------
+    :
+        A dictionary of the current values/state of each input widget.
+
+    Raises
+    ------
+    TypeError:
+        If the widget is not a WorkflowWidget or a ParameterBox.
+
+    """
+    return {
+        node: get_fields(widget)
+        for node, widget in _get_parameter_box(widget)._input_widgets.items()
+    }

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/uncertainty.py

@@ -13,7 +13,7 @@ The recommended use of this module is via the :py:func:`broadcast_uncertainties`
 helper function.
 """
 
-from enum import Enum
+from enum import Enum, auto
 from typing import TypeVar, overload
 
 import numpy as np
@@ -23,18 +23,18 @@ from scipp.core.concepts import irreducible_mask
 T = TypeVar("T", bound=sc.Variable | sc.DataArray)
 
 
-UncertaintyBroadcastMode = Enum(
-    'UncertaintyBroadcastMode', ['drop', 'upper_bound', 'fail']
-)
-"""
-Mode for broadcasting uncertainties.
+class UncertaintyBroadcastMode(Enum):
+    """Mode for broadcasting uncertainties.
 
-- `drop`: Drop variances if the data is broadcasted.
-- `upper_bound`: Compute an upper bound for the variances.
-- `fail`: Do not broadcast, simply return the input data.
+    See https://doi.org/10.3233/JNR-220049 for context.
+    """
 
-See https://doi.org/10.3233/JNR-220049 for context.
-"""
+    drop = auto()
+    """Drop variances if the data is broadcast."""
+    upper_bound = auto()
+    """Compute an upper bound for the variances."""
+    fail = auto()
+    """Do not broadcast, simply return the input data."""
 
 
 @overload

essreduce-24.12.0/src/ess/reduce/widgets/_base.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2024 Scipp contributors (https://github.com/scipp)
+import warnings
+from typing import Any, Protocol, runtime_checkable
+
+from ipywidgets import Widget
+
+
+@runtime_checkable
+class WidgetWithFieldsProtocol(Protocol):
+    def set_fields(self, new_values: dict[str, Any]) -> None: ...
+
+    def get_fields(self) -> dict[str, Any]: ...
+
+
+class WidgetWithFieldsMixin:
+    def set_fields(self, new_values: dict[str, Any]) -> None:
+        # Extract valid fields
+        new_field_names = set(new_values.keys())
+        valid_field_names = new_field_names & set(self.fields.keys())
+        # Warn for invalid fields
+        invalid_field_names = new_field_names - valid_field_names
+        for field_name in invalid_field_names:
+            warning_msg = f"Cannot set field '{field_name}'."
+            " The field does not exist in the widget."
+            "The field value will be ignored."
+            warnings.warn(warning_msg, UserWarning, stacklevel=1)
+        # Set valid fields
+        for field_name in valid_field_names:
+            self.fields[field_name].value = new_values[field_name]
+
+    def get_fields(self) -> dict[str, Any]:
+        return {
+            field_name: field_sub_widget.value
+            for field_name, field_sub_widget in self.fields.items()
+        }
+
+
+def _has_widget_value_setter(widget: Widget) -> bool:
+    widget_type = type(widget)
+    return (
+        widget_property := getattr(widget_type, 'value', None)
+    ) is not None and getattr(widget_property, 'fset', None) is not None
+
+
+def set_fields(widget: Widget, new_values: Any) -> None:
+    if isinstance(widget, WidgetWithFieldsProtocol) and isinstance(new_values, dict):
+        widget.set_fields(new_values)
+    elif _has_widget_value_setter(widget):
+        widget.value = new_values
+    else:
+        warnings.warn(
+            f"Cannot set value or fields for widget of type {type(widget)}."
+            " The new_value(s) will be ignored.",
+            UserWarning,
+            stacklevel=1,
+        )
+
+
+def get_fields(widget: Widget) -> Any:
+    if isinstance(widget, WidgetWithFieldsProtocol):
+        return widget.get_fields()
+    return widget.value

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/widgets/_binedges_widget.py

@@ -3,6 +3,8 @@
 import ipywidgets as ipw
 import scipp as sc
 
+from ._base import WidgetWithFieldsMixin
+
 UNITS_LIBRARY = {
     "wavelength": {"options": ("angstrom", "nm")},
     "Q": {"options": ("1/angstrom", "1/nm")},
@@ -19,7 +21,7 @@ UNITS_LIBRARY = {
 }
 
 
-class BinEdgesWidget(ipw.HBox, ipw.ValueWidget):
+class BinEdgesWidget(ipw.HBox, ipw.ValueWidget, WidgetWithFieldsMixin):
     def __init__(
         self,
         name: str,

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/widgets/_bounds_widget.py

@@ -4,9 +4,10 @@ import scipp as sc
 from ipywidgets import FloatText, GridBox, Label, Text, ValueWidget
 
 from ..parameter import ParamWithBounds
+from ._base import WidgetWithFieldsMixin
 
 
-class BoundsWidget(GridBox, ValueWidget):
+class BoundsWidget(GridBox, ValueWidget, WidgetWithFieldsMixin):
     def __init__(self):
         super().__init__()
 

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/widgets/_linspace_widget.py

@@ -3,8 +3,10 @@
 import scipp as sc
 from ipywidgets import FloatText, GridBox, IntText, Label, ValueWidget
 
+from ._base import WidgetWithFieldsMixin
 
-class LinspaceWidget(GridBox, ValueWidget):
+
+class LinspaceWidget(GridBox, ValueWidget, WidgetWithFieldsMixin):
     def __init__(self, dim: str, unit: str):
         super().__init__()
 

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/widgets/_string_widget.py

@@ -27,6 +27,15 @@ class StringWidget(HBox, ValueWidget):
 
 
 class MultiStringWidget(StringWidget):
+    def __init__(
+        self, description: str, value: tuple[str, ...] | None = None, **kwargs
+    ):
+        # Special case handling to allow initialising with a single string
+        if not isinstance(value, str) and value is not None:
+            value = ', '.join(value)
+
+        super().__init__(description, value, **kwargs)
+
     @property
     def value(self) -> tuple[str, ...]:
         v = super().value

{essreduce-24.11.3 → essreduce-24.12.0}/src/ess/reduce/widgets/_vector_widget.py

@@ -4,8 +4,10 @@
 import scipp as sc
 from ipywidgets import FloatText, HBox, Label, Text, ValueWidget
 
+from ._base import WidgetWithFieldsMixin
 
-class VectorWidget(HBox, ValueWidget):
+
+class VectorWidget(HBox, ValueWidget, WidgetWithFieldsMixin):
     def __init__(self, name: str, variable: sc.Variable, components: str):
         super().__init__()
 

{essreduce-24.11.3 → essreduce-24.12.0/src/essreduce.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: essreduce
-Version: 24.11.3
+Version: 24.12.0
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License

{essreduce-24.11.3 → essreduce-24.12.0}/src/essreduce.egg-info/SOURCES.txt

@@ -83,6 +83,7 @@ src/ess/reduce/nexus/types.py
 src/ess/reduce/nexus/workflow.py
 src/ess/reduce/scripts/grow_nexus.py
 src/ess/reduce/widgets/__init__.py
+src/ess/reduce/widgets/_base.py
 src/ess/reduce/widgets/_binedges_widget.py
 src/ess/reduce/widgets/_bounds_widget.py
 src/ess/reduce/widgets/_config.py

{essreduce-24.11.3 → essreduce-24.12.0}/tests/nexus/workflow_test.py

@@ -12,16 +12,20 @@ from ess.reduce.nexus.types import (
     BackgroundRun,
     Choppers,
     DetectorData,
+    EmptyBeamRun,
     Filename,
     Monitor1,
     Monitor2,
     Monitor3,
     MonitorData,
+    MonitorType,
     NeXusComponentLocationSpec,
     NeXusName,
     NeXusTransformation,
+    RunType,
     SampleRun,
     TimeInterval,
+    TransmissionMonitor,
 )
 from ess.reduce.nexus.workflow import (
     GenericNeXusWorkflow,
@@ -574,16 +578,11 @@ def test_generic_nexus_workflow_load_analyzers() -> None:
     assert analyzer['usage'] == 'Bragg'
 
 
-def test_generic_nexus_workflow_raises_if_monitor_types_but_not_run_types_given() -> (
-    None
-):
-    with pytest.raises(ValueError, match='run_types'):
-        GenericNeXusWorkflow(monitor_types=[Monitor1])
-
-
 def test_generic_nexus_workflow_includes_only_given_run_and_monitor_types() -> None:
     wf = GenericNeXusWorkflow(run_types=[SampleRun], monitor_types=[Monitor1, Monitor3])
     graph = wf.underlying_graph
+
+    # Check some examples to avoid relying entirely on complicated loops below.
     assert DetectorData[SampleRun] in graph
     assert DetectorData[BackgroundRun] not in graph
     assert MonitorData[SampleRun, Monitor1] in graph
@@ -592,7 +591,11 @@ def test_generic_nexus_workflow_includes_only_given_run_and_monitor_types() -> N
     assert MonitorData[BackgroundRun, Monitor1] not in graph
     assert MonitorData[BackgroundRun, Monitor2] not in graph
     assert MonitorData[BackgroundRun, Monitor3] not in graph
-    # Many other keys are also removed, this is just an example
+    assert Choppers[SampleRun] in graph
+    assert Choppers[BackgroundRun] not in graph
+    assert Analyzers[SampleRun] in graph
+    assert Analyzers[BackgroundRun] not in graph
+
     assert NeXusComponentLocationSpec[Monitor1, SampleRun] in graph
     assert NeXusComponentLocationSpec[Monitor2, SampleRun] not in graph
     assert NeXusComponentLocationSpec[Monitor3, SampleRun] in graph
@@ -605,3 +608,66 @@ def test_generic_nexus_workflow_includes_only_given_run_and_monitor_types() -> N
     assert NeXusComponentLocationSpec[snx.NXdetector, BackgroundRun] not in graph
     assert NeXusComponentLocationSpec[snx.NXsample, BackgroundRun] not in graph
     assert NeXusComponentLocationSpec[snx.NXsource, BackgroundRun] not in graph
+
+    excluded_run_types = set(RunType.__constraints__) - {SampleRun}
+    excluded_monitor_types = set(MonitorType.__constraints__) - {Monitor1, Monitor3}
+    for node in graph:
+        assert_not_contains_type_arg(node, excluded_run_types)
+        assert_not_contains_type_arg(node, excluded_monitor_types)
+
+
+def test_generic_nexus_workflow_includes_only_given_run_types() -> None:
+    wf = GenericNeXusWorkflow(run_types=[EmptyBeamRun])
+    graph = wf.underlying_graph
+
+    # Check some examples to avoid relying entirely on complicated loops below.
+    assert DetectorData[EmptyBeamRun] in graph
+    assert DetectorData[SampleRun] not in graph
+    assert MonitorData[EmptyBeamRun, Monitor1] in graph
+    assert MonitorData[EmptyBeamRun, Monitor2] in graph
+    assert MonitorData[EmptyBeamRun, Monitor3] in graph
+    assert MonitorData[SampleRun, Monitor1] not in graph
+    assert MonitorData[SampleRun, Monitor2] not in graph
+    assert MonitorData[SampleRun, Monitor3] not in graph
+    assert Choppers[EmptyBeamRun] in graph
+    assert Choppers[SampleRun] not in graph
+    assert Analyzers[EmptyBeamRun] in graph
+    assert Analyzers[SampleRun] not in graph
+
+    excluded_run_types = set(RunType.__constraints__) - {EmptyBeamRun}
+    for node in graph:
+        assert_not_contains_type_arg(node, excluded_run_types)
+
+
+def test_generic_nexus_workflow_includes_only_given_monitor_types() -> None:
+    wf = GenericNeXusWorkflow(monitor_types=[TransmissionMonitor, Monitor1])
+    graph = wf.underlying_graph
+
+    # Check some examples to avoid relying entirely on complicated loops below.
+    assert DetectorData[SampleRun] in graph
+    assert DetectorData[BackgroundRun] in graph
+    assert MonitorData[SampleRun, TransmissionMonitor] in graph
+    assert MonitorData[SampleRun, Monitor1] in graph
+    assert MonitorData[SampleRun, Monitor2] not in graph
+    assert MonitorData[SampleRun, Monitor3] not in graph
+    assert MonitorData[BackgroundRun, TransmissionMonitor] in graph
+    assert MonitorData[BackgroundRun, Monitor1] in graph
+    assert MonitorData[BackgroundRun, Monitor2] not in graph
+    assert MonitorData[BackgroundRun, Monitor3] not in graph
+    assert Choppers[SampleRun] in graph
+    assert Choppers[BackgroundRun] in graph
+    assert Analyzers[SampleRun] in graph
+    assert Analyzers[BackgroundRun] in graph
+
+    excluded_monitor_types = set(MonitorType.__constraints__) - {
+        Monitor1,
+        TransmissionMonitor,
+    }
+    for node in graph:
+        assert_not_contains_type_arg(node, excluded_monitor_types)
+
+
+def assert_not_contains_type_arg(node: object, excluded: set[type]) -> None:
+    assert not any(
+        arg in excluded for arg in getattr(node, "__args__", ())
+    ), f"Node {node} contains one of {excluded!r}"

{essreduce-24.11.3 → essreduce-24.12.0}/tests/widget_test.py

@@ -4,12 +4,19 @@ from collections.abc import Callable, Generator
 from contextlib import contextmanager
 from typing import Any, NewType
 
+import pytest
 import sciline as sl
 import scipp as sc
 from ipywidgets import FloatText, IntText
 
-from ess.reduce.parameter import BinEdgesParameter, Parameter, parameter_registry
-from ess.reduce.ui import WorkflowWidget, workflow_widget
+from ess.reduce.parameter import (
+    BinEdgesParameter,
+    FilenameParameter,
+    MultiFilenameParameter,
+    Parameter,
+    parameter_registry,
+)
+from ess.reduce.ui import ResultBox, WorkflowWidget, workflow_widget
 from ess.reduce.widgets import OptionalWidget, SwitchWidget, create_parameter_widget
 from ess.reduce.workflow import register_workflow, workflow_registry
 
@@ -79,7 +86,7 @@ def provider_with_optional(a: OptionalInt, b: OptionalFloat) -> str:
 
 
 def _get_param_widget(widget: WorkflowWidget, param_type: type) -> Any:
-    return widget.parameter_box._input_widgets[param_type].children[0]
+    return widget.parameter_box._input_widgets[param_type]
 
 
 def test_parameter_default_value_test() -> None:
@@ -402,3 +409,71 @@ def test_bin_edges_widget_with_default_values() -> None:
     assert param_widget.fields['stop'].value == 0.6
     assert param_widget.fields['nbins'].value == 150
     assert param_widget.fields['spacing'].value == 'linear'
+
+
+@pytest.mark.parametrize(
+    'output',
+    [
+        (sc.scalar(1), sc.scalar(2)),
+        'Test with a string',
+        sc.data.binned_xy(100, 10, 10),
+    ],
+)
+def test_result_box_can_handle_different_outputs(output):
+    was_called = False
+
+    def run_workflow():
+        nonlocal was_called
+        was_called = True
+        return dict(enumerate(output))
+
+    ResultBox(run_workflow).run_button.click()
+    assert was_called
+
+
+FilenameSampleRun = NewType('FilenameSampleRun', str)
+parameter_registry[FilenameSampleRun] = FilenameParameter.from_type(
+    FilenameSampleRun, default="SampleRun.hdf"
+)
+MultiFilenameSampleRun = NewType('MultiFilenameSampleRun', list[str])
+parameter_registry[MultiFilenameSampleRun] = MultiFilenameParameter.from_type(
+    MultiFilenameSampleRun, default=["file1.hdf", "file2.hdf"]
+)
+MultiFilenameBackgroundRun = NewType('MultiFilenameBackgroundRun', list[str])
+parameter_registry[MultiFilenameBackgroundRun] = MultiFilenameParameter.from_type(
+    MultiFilenameBackgroundRun, default="background.hdf"
+)
+
+
+def filename_print_provider(fname: FilenameSampleRun) -> str:
+    return str(fname)
+
+
+def multi_filename_print_provider(fnames: MultiFilenameSampleRun) -> list[str]:
+    return [str(fname) for fname in fnames]
+
+
+def multi_filename_print_provider_bis(fnames: MultiFilenameBackgroundRun) -> list[str]:
+    return [str(fname) for fname in fnames]
+
+
+def test_filename_widget_single() -> None:
+    widget = _ready_widget(providers=[filename_print_provider], output_selections=[str])
+    param_widget = _get_param_widget(widget, FilenameSampleRun)
+    assert param_widget.value == "SampleRun.hdf"
+
+
+def test_filename_widget_multiple() -> None:
+    widget = _ready_widget(
+        providers=[multi_filename_print_provider], output_selections=[list[str]]
+    )
+    param_widget = _get_param_widget(widget, MultiFilenameSampleRun)
+    assert param_widget.value == ("file1.hdf", "file2.hdf")
+
+
+def test_filename_widget_multiple_initialized_with_single_string() -> None:
+    widget = _ready_widget(
+        providers=[multi_filename_print_provider_bis], output_selections=[list[str]]
+    )
+    param_widget = _get_param_widget(widget, MultiFilenameBackgroundRun)
+    assert param_widget.value == ("background.hdf",)