Add plot grid

src/ess/livedata/dashboard/plot_configuration_adapter.py

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+from __future__ import annotations
+
+from typing import Any
+
+import pydantic
+
+from ess.livedata.config.workflow_spec import JobNumber
+from ess.livedata.dashboard.configuration_adapter import ConfigurationAdapter
+from ess.livedata.dashboard.plotting import PlotterSpec
+from ess.livedata.dashboard.plotting_controller import PlottingController
+
+
+class PlotConfigurationAdapter(ConfigurationAdapter):
+    """Adapter for plot configuration modal."""
+
+    def __init__(
+        self,
+        job_number: JobNumber,
+        output_name: str | None,
+        plot_spec: PlotterSpec,
+        available_sources: list[str],
+        plotting_controller: PlottingController,
+        success_callback,
+    ):
+        self._job_number = job_number
+        self._output_name = output_name
+        self._plot_spec = plot_spec
+        self._available_sources = available_sources
+        self._plotting_controller = plotting_controller
+        self._success_callback = success_callback
+
+        self._persisted_config = (
+            self._plotting_controller.get_persistent_plotter_config(
+                job_number=self._job_number,
+                output_name=self._output_name,
+                plot_name=self._plot_spec.name,
+            )
+        )
+
+    @property
+    def title(self) -> str:
+        return f"Configure {self._plot_spec.title}"
+
+    @property
+    def description(self) -> str:
+        return self._plot_spec.description
+
+    def model_class(self) -> type[pydantic.BaseModel] | None:
+        return self._plot_spec.params
+
+    @property
+    def source_names(self) -> list[str]:
+        return self._available_sources
+
+    @property
+    def initial_source_names(self) -> list[str]:
+        if self._persisted_config is not None:
+            # Filter persisted source names to only include those still available
+            persisted_sources = [
+                name
+                for name in self._persisted_config.source_names
+                if name in self._available_sources
+            ]
+            return persisted_sources if persisted_sources else self._available_sources
+        return self._available_sources
+
+    @property
+    def initial_parameter_values(self) -> dict[str, Any]:
+        if self._persisted_config is not None:
+            return self._persisted_config.config.params
+        return {}
+
+    def start_action(
+        self,
+        selected_sources: list[str],
+        parameter_values: Any,
+    ) -> None:
+        """Create the plot and call the success callback with the result."""
+        plot = self._plotting_controller.create_plot(
+            job_number=self._job_number,
+            source_names=selected_sources,
+            output_name=self._output_name,
+            plot_name=self._plot_spec.name,
+            params=parameter_values,
+        )
+        self._success_callback(plot, selected_sources)

src/ess/livedata/dashboard/reduction.py

@@ -10,7 +10,7 @@
 from .dashboard import DashboardBase
 from .widgets.log_producer_widget import LogProducerWidget
 
-pn.extension('holoviews', 'modal', template='material')
+pn.extension('holoviews', 'modal', notifications=True, template='material')
 hv.extension('bokeh')
 
 

src/ess/livedata/dashboard/widgets/configuration_widget.py

@@ -113,11 +113,11 @@ def _on_aux_source_changed(self, event) -> None:
                 break
 
         if widget_index is not None:
-            self._widget.objects = (
-                self._widget.objects[:widget_index]
-                + [self._model_widget.widget]
-                + self._widget.objects[widget_index + 1 :]
-            )
+            self._widget.objects = [
+                *self._widget.objects[:widget_index],
+                self._model_widget.widget,
+                *self._widget.objects[widget_index + 1 :],
+            ]
 
     def _create_widget(self) -> pn.Column:
         """Create the main configuration widget."""
@@ -198,121 +198,91 @@ def clear_validation_errors(self) -> None:
         self._model_widget.clear_validation_errors()
 
 
-class ConfigurationModal:
-    """Generic modal dialog for configuration."""
+class ConfigurationPanel:
+    """Reusable configuration panel with validation and action execution."""
 
     def __init__(
         self,
         config: ConfigurationAdapter,
-        start_button_text: str = "Start",
-        success_callback: Callable[[], None] | None = None,
-        error_callback: Callable[[str], None] | None = None,
     ) -> None:
         """
-        Initialize generic configuration modal.
+        Initialize configuration panel.
 
         Parameters
         ----------
         config
             Configuration adapter providing data and callbacks
-        start_button_text
-            Text for the start button
-        success_callback
-            Called when action completes successfully
-        error_callback
-            Called when an error occurs
         """
         self._config = config
         self._config_widget = ConfigurationWidget(config)
-        self._success_callback = success_callback
-        self._error_callback = error_callback
         self._error_pane = pn.pane.HTML("", sizing_mode='stretch_width')
-        self._modal = self._create_modal(start_button_text)
         self._logger = logging.getLogger(__name__)
+        self._panel = self._create_panel()
 
-    def _create_modal(self, start_button_text: str) -> pn.Modal:
-        """Create the modal dialog."""
-        start_button = pn.widgets.Button(name=start_button_text, button_type="primary")
-        start_button.on_click(self._on_start_action)
-
-        cancel_button = pn.widgets.Button(name="Cancel", button_type="light")
-        cancel_button.on_click(self._on_cancel)
-
-        content = pn.Column(
+    def _create_panel(self) -> pn.Column:
+        """Create the configuration panel."""
+        return pn.Column(
             self._config_widget.widget,
             self._error_pane,
-            pn.Row(pn.Spacer(), cancel_button, start_button, margin=(10, 0)),
-        )
-
-        modal = pn.Modal(
-            content,
-            name=f"Configure {self._config.title}",
-            margin=20,
-            width=800,
-            height=800,
         )
 
-        # Watch for modal close events to clean up
-        modal.param.watch(self._on_modal_closed, 'open')
-
-        return modal
-
-    def _on_cancel(self, event) -> None:
-        """Handle cancel button click."""
-        self._modal.open = False
-
-    def _on_modal_closed(self, event) -> None:
-        """Handle modal being closed (cleanup)."""
-        if not event.new:  # Modal was closed
-            # Remove modal from its parent container after a short delay
-            # to allow the close animation to complete
-            def cleanup():
-                try:
-                    if hasattr(self._modal, '_parent') and self._modal._parent:
-                        self._modal._parent.remove(self._modal)
-                except Exception:  # noqa: S110
-                    pass  # Ignore cleanup errors
-
-            pn.state.add_periodic_callback(cleanup, period=100, count=1)
+    def validate(self) -> tuple[bool, list[str]]:
+        """
+        Validate configuration and show errors inline.
 
-    def _on_start_action(self, event) -> None:
-        """Handle start action button click."""
-        # Clear previous errors
+        Returns
+        -------
+        :
+            Tuple of (is_valid, list_of_error_messages)
+        """
         self._config_widget.clear_validation_errors()
         self._error_pane.object = ""
 
-        # Validate configuration
         is_valid, errors = self._config_widget.validate_configuration()
 
         if not is_valid:
             self._show_validation_errors(errors)
-            return
 
-        # Execute the start action and handle any exceptions
+        return is_valid, errors
+
+    def execute_action(self) -> bool:
+        """
+        Execute the configuration action.
+
+        Assumes validation has already passed. If validation is needed,
+        use validate() first or use validate_and_execute().
+
+        Returns
+        -------
+        :
+            True if action succeeded, False if action raised error
+        """
         try:
             self._config.start_action(
                 self._config_widget.selected_sources,
                 self._config_widget.parameter_values,
             )
         except Exception as e:
-            # Log the full exception with stack trace
             self._logger.exception("Error starting '%s'", self._config.title)
-
-            # Show user-friendly error message
             error_message = f"Error starting '{self._config.title}': {e!s}"
             self._show_action_error(error_message)
+            return False
 
-            # Notify error callback if provided
-            if self._error_callback:
-                self._error_callback(error_message)
+        return True
 
-            # Keep modal open so user can correct the issue or see the error
-            return
+    def validate_and_execute(self) -> bool:
+        """
+        Convenience method: validate then execute if valid.
 
-        # Success - close modal and notify success callback
-        self._modal.open = False
-        if self._success_callback:
-            self._success_callback()
+        Returns
+        -------
+        :
+            True if both validation and execution succeeded, False otherwise
+        """
+        is_valid, _ = self.validate()
+        if not is_valid:
+            return False
+        return self.execute_action()
 
     def _show_validation_errors(self, errors: list[str]) -> None:
         """Show validation errors inline."""
@@ -339,6 +309,102 @@ def _show_action_error(self, message: str) -> None:
         )
         self._error_pane.object = error_html
 
+    @property
+    def panel(self) -> pn.Column:
+        """Get the panel widget."""
+        return self._panel
+
+
+class ConfigurationModal:
+    """Modal wrapper around ConfigurationPanel with action buttons."""
+
+    def __init__(
+        self,
+        config: ConfigurationAdapter,
+        start_button_text: str = "Start",
+        success_callback: Callable[[], None] | None = None,
+    ) -> None:
+        """
+        Initialize configuration modal.
+
+        Parameters
+        ----------
+        config
+            Configuration adapter providing data and callbacks
+        start_button_text
+            Text for the start button
+        success_callback
+            Called when action completes successfully
+        """
+        self._config = config
+        self._success_callback = success_callback
+
+        # Create panel
+        self._panel = ConfigurationPanel(config=config)
+
+        # Create action buttons
+        self._start_button = pn.widgets.Button(
+            name=start_button_text, button_type="primary"
+        )
+        self._start_button.on_click(self._on_start_clicked)
+
+        self._cancel_button = pn.widgets.Button(name="Cancel", button_type="light")
+        self._cancel_button.on_click(self._on_cancel_clicked)
+
+        # Create modal with panel + buttons
+        self._modal = self._create_modal()
+
+    def _create_modal(self) -> pn.Modal:
+        """Create the modal dialog."""
+        # Combine panel with buttons
+        content = pn.Column(
+            self._panel.panel,
+            pn.Row(
+                pn.Spacer(),
+                self._cancel_button,
+                self._start_button,
+                margin=(10, 0),
+            ),
+        )
+
+        modal = pn.Modal(
+            content,
+            name=f"Configure {self._config.title}",
+            margin=20,
+            width=800,
+            height=800,
+        )
+
+        # Watch for modal close events to clean up
+        modal.param.watch(self._on_modal_closed, 'open')
+
+        return modal
+
+    def _on_start_clicked(self, event) -> None:
+        """Handle start button click."""
+        if self._panel.validate_and_execute():
+            self._modal.open = False
+            if self._success_callback:
+                self._success_callback()
+
+    def _on_cancel_clicked(self, event) -> None:
+        """Handle cancel button click."""
+        self._modal.open = False
+
+    def _on_modal_closed(self, event) -> None:
+        """Handle modal being closed (cleanup)."""
+        if not event.new:  # Modal was closed
+            # Remove modal from its parent container after a short delay
+            # to allow the close animation to complete
+            def cleanup():
+                try:
+                    if hasattr(self._modal, '_parent') and self._modal._parent:
+                        self._modal._parent.remove(self._modal)
+                except Exception:  # noqa: S110
+                    pass  # Ignore cleanup errors
+
+            pn.state.add_periodic_callback(cleanup, period=100, count=1)
+
     def show(self) -> None:
         """Show the modal dialog."""
         self._modal.open = True