syd 0.2.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

syd/notebook_deployment/deployer.py

@@ -1,27 +1,15 @@
-from typing import Dict, Any, Optional
+from typing import Literal, Optional
 import warnings
-from functools import wraps
-from dataclasses import dataclass
+import threading
 from contextlib import contextmanager
-from time import time
-
 import ipywidgets as widgets
 from IPython.display import display
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
-from ..parameters import ParameterUpdateWarning
+from ..support import ParameterUpdateWarning, plot_context
 from ..viewer import Viewer
-from .widgets import BaseWidget, create_widget
-
-
-@contextmanager
-def _plot_context():
-    plt.ioff()
-    try:
-        yield
-    finally:
-        plt.ion()
+from .widgets import create_widget, BaseWidget
 
 
 def get_backend_type():
@@ -40,47 +28,6 @@ def get_backend_type():
         return "other"
 
 
-def debounce(wait_time):
-    """
-    Decorator to prevent a function from being called more than once every wait_time seconds.
-    """
-
-    def decorator(fn):
-        last_called = [0.0]  # Using list to maintain state in closure
-
-        @wraps(fn)
-        def debounced(*args, **kwargs):
-            current_time = time()
-            if current_time - last_called[0] >= wait_time:
-                fn(*args, **kwargs)
-                last_called[0] = current_time
-
-        return debounced
-
-    return decorator
-
-
-@dataclass
-class LayoutConfig:
-    """Configuration for the viewer layout."""
-
-    controls_position: str = "left"  # Options are: 'left', 'top', 'right', 'bottom'
-    figure_width: float = 8.0
-    figure_height: float = 6.0
-    controls_width_percent: int = 20
-
-    def __post_init__(self):
-        valid_positions = ["left", "top", "right", "bottom"]
-        if self.controls_position not in valid_positions:
-            raise ValueError(
-                f"Invalid controls position: {self.controls_position}. Must be one of {valid_positions}"
-            )
-
-    @property
-    def is_horizontal(self) -> bool:
-        return self.controls_position == "left" or self.controls_position == "right"
-
-
 class NotebookDeployer:
     """
     A deployment system for Viewer in Jupyter notebooks using ipywidgets.
@@ -90,50 +37,105 @@ class NotebookDeployer:
     def __init__(
         self,
         viewer: Viewer,
-        controls_position: str = "left",
-        figure_width: float = 8.0,
-        figure_height: float = 6.0,
+        controls_position: Literal["left", "top", "right", "bottom"] = "left",
         controls_width_percent: int = 20,
         continuous: bool = False,
-        suppress_warnings: bool = False,
+        suppress_warnings: bool = True,
+        update_threshold: float = 1.0,
     ):
         self.viewer = viewer
-        self.config = LayoutConfig(
-            controls_position=controls_position,
-            figure_width=figure_width,
-            figure_height=figure_height,
-            controls_width_percent=controls_width_percent,
-        )
-        self.continuous = continuous
+        self.components: dict[str, BaseWidget] = {}
         self.suppress_warnings = suppress_warnings
+        self._updating = False  # Flag to check circular updates
+        self.controls_position = controls_position
+        self.controls_width_percent = controls_width_percent
+        self.continuous = continuous
 
         # Initialize containers
         self.backend_type = get_backend_type()
         if self.backend_type not in ["inline", "widget"]:
             warnings.warn(
                 f"The current backend ({self.backend_type}) is not supported. Please use %matplotlib widget or %matplotlib inline.\n"
-                "The behavior of the viewer will almost definitely not work as expected."
+                "The behavior of the viewer will almost definitely not work as expected!"
             )
-        self.parameter_widgets: Dict[str, BaseWidget] = {}
-        self.plot_output = widgets.Output()
+        self._last_figure = None
+        self._update_event = threading.Event()
+        self.update_threshold = update_threshold
+        self._slow_loading_figure = None
+        self._display_lock = threading.Lock()  # Lock for synchronizing display updates
+
+    def _show_slow_loading(self):
+        if self.backend_type == "inline":
+            if not self._update_event.wait(self.update_threshold):
+                if self._slow_loading_figure is None:
+                    fig = plt.figure()
+                    ax = fig.add_subplot(111)
+                    ax.text(
+                        0.5,
+                        0.5,
+                        "waiting for next figure...",
+                        ha="center",
+                        va="center",
+                        fontsize=12,
+                        weight="bold",
+                        color="black",
+                    )
+                    ax.axis("off")
+                    self._slow_loading_figure = fig
+                if not self._showing_new_figure:
+                    self._display_figure(self._slow_loading_figure, store_figure=False)
+                    self._showing_slow_loading_figure = True
+
+    @contextmanager
+    def _perform_update(self):
+        self._updating = True
+        self._showing_new_figure = False
+        self._showing_slow_loading_figure = False
+        self._update_event.clear()
+
+        thread = threading.Thread(target=self._show_slow_loading, daemon=True)
+        thread.start()
 
-        # Create layout for controls
-        self.layout_widgets = self._create_layout_controls()
+        try:
+            yield
+        finally:
+            self._updating = False
+            self._update_event.set()
+            thread.join()
+            if self._showing_slow_loading_figure:
+                self._display_figure(self._last_figure)
+            self._update_status("Ready!")
+
+    def deploy(self) -> None:
+        """Deploy the viewer."""
+        self.backend_type = get_backend_type()
+        self.build_components()
+        self.build_layout()
+        display(self.layout)
+        self.update_plot()
 
-        # Flag to prevent circular updates
-        self._updating = False
+    def build_components(self) -> None:
+        """Create widget instances for all parameters and equip callbacks."""
+        for name, param in self.viewer.parameters.items():
+            widget = create_widget(param, continuous=self.continuous)
+            self.components[name] = widget
+            callback = lambda _, n=name: self.handle_component_engagement(n)
+            widget.observe(callback)
 
-        # Last figure to close when new figures are created
-        self._last_figure = None
+    def build_layout(self) -> None:
+        """Create the main layout combining controls and plot."""
 
-    def _create_layout_controls(self) -> Dict[str, widgets.Widget]:
-        """Create widgets for controlling the layout."""
-        controls: Dict[str, widgets.Widget] = {}
+        self.plot_output = widgets.Output()
 
         # Controls width slider for horizontal layouts
-        if self.config.is_horizontal:
-            controls["controls_width"] = widgets.IntSlider(
-                value=self.config.controls_width_percent,
+        self.controls = {}
+        self.controls["status"] = widgets.HTML(
+            value="<b>Syd Controls</b>",
+            layout=widgets.Layout(width="95%"),
+        )
+        if self.controls_position in ["left", "right"]:
+            self.controls["controls_width"] = widgets.IntSlider(
+                value=self.controls_width_percent,
                 min=10,
                 max=50,
                 description="Controls Width %",
@@ -141,144 +143,42 @@ class NotebookDeployer:
                 layout=widgets.Layout(width="95%"),
                 style={"description_width": "initial"},
             )
-
-        return controls
-
-    def _create_parameter_widgets(self) -> None:
-        """Create widget instances for all parameters."""
-        for name, param in self.viewer.parameters.items():
-            widget = create_widget(
-                param,
-                continuous=self.continuous,
-            )
-
-            # Store in widget dict
-            self.parameter_widgets[name] = widget
-
-    @debounce(0.1)
-    def _handle_widget_engagement(self, name: str) -> None:
-        """Handle engagement with an interactive widget."""
-        if self._updating:
-            print(
-                "Already updating -- there's a circular dependency!"
-                "This is probably caused by failing to disable callbacks for a parameter."
-                "It's a bug --- tell the developer on github issues please."
+        if self.backend_type == "inline":
+            self.controls["update_threshold"] = widgets.FloatSlider(
+                value=self.update_threshold,
+                min=0.1,
+                max=10.0,
+                description="Update Threshold",
+                layout=widgets.Layout(width="95%"),
+                style={"description_width": "initial"},
             )
-            return
-
-        try:
-            self._updating = True
-
-            # Optionally suppress warnings during parameter updates
-            with warnings.catch_warnings():
-                if self.suppress_warnings:
-                    warnings.filterwarnings("ignore", category=ParameterUpdateWarning)
-
-                widget = self.parameter_widgets[name]
-
-                if widget._is_action:
-                    parameter = self.viewer.parameters[name]
-                    parameter.callback(self.viewer.state)
-                else:
-                    self.viewer.set_parameter_value(name, widget.value)
-
-                # Update any widgets that changed due to dependencies
-                self._sync_widgets_with_state()
-
-                # Update the plot
-                self._update_plot()
-
-        finally:
-            self._updating = False
-
-    def _handle_action(self, name: str) -> None:
-        """Handle actions for parameter widgets."""
-
-    def _sync_widgets_with_state(self, exclude: Optional[str] = None) -> None:
-        """Sync widget values with viewer state."""
-        for name, parameter in self.viewer.parameters.items():
-            if name == exclude:
-                continue
-
-            widget = self.parameter_widgets[name]
-            if not widget.matches_parameter(parameter):
-                widget.update_from_parameter(parameter)
-
-    def _handle_figure_size_change(self, change: Dict[str, Any]) -> None:
-        """Handle changes to figure dimensions."""
-        if self._current_figure is None:
-            return
-
-        self._redraw_plot()
-
-    def _handle_container_width_change(self, change: Dict[str, Any]) -> None:
-        """Handle changes to container width proportions."""
-        width_percent = self.layout_widgets["controls_width"].value
-        self.config.controls_width_percent = width_percent
-
-        # Update container widths
-        self.widgets_container.layout.width = f"{width_percent}%"
-        self.plot_container.layout.width = f"{100 - width_percent}%"
-
-    def _update_plot(self) -> None:
-        """Update the plot with current state."""
-        state = self.viewer.state
-
-        with _plot_context():
-            figure = self.viewer.plot(state)
-
-        # Update widgets if plot function updated a parameter
-        self._sync_widgets_with_state()
-
-        # Close the last figure if it exists to keep matplotlib clean
-        # (just moved this from after clear_output.... noting!)
-        if self._last_figure is not None:
-            plt.close(self._last_figure)
-
-        self.plot_output.clear_output(wait=True)
-        with self.plot_output:
-            if self.backend_type == "inline":
-                display(figure)
-
-                # Also required to make sure a second figure window isn't opened
-                plt.close(figure)
-
-            elif self.backend_type == "widget":
-                display(figure.canvas)
-
-            else:
-                raise ValueError(f"Unsupported backend type: {self.backend_type}")
-
-        self._last_figure = figure
-
-    def _create_layout(self) -> widgets.Widget:
-        """Create the main layout combining controls and plot."""
-        # Set up parameter widgets with their observe callbacks
-        for name, widget in self.parameter_widgets.items():
-            widget.observe(lambda change, n=name: self._handle_widget_engagement(n))
 
         # Create parameter controls section
         param_box = widgets.VBox(
             [widgets.HTML("<b>Parameters</b>")]
-            + [w.widget for w in self.parameter_widgets.values()],
+            + [w.widget for w in self.components.values()],
             layout=widgets.Layout(margin="10px 0px"),
         )
 
         # Combine all controls
-        if self.config.is_horizontal:
+        if self.controls_position in ["left", "right"]:
             # Create layout controls section if horizontal (might include for vertical later when we have more permanent controls...)
             layout_box = widgets.VBox(
-                [widgets.HTML("<b>Layout Controls</b>")]
-                + list(self.layout_widgets.values()),
+                list(self.controls.values()),
                 layout=widgets.Layout(margin="10px 0px"),
             )
 
             # Register the controls_width slider's observer
-            if "controls_width" in self.layout_widgets:
-                self.layout_widgets["controls_width"].observe(
+            if "controls_width" in self.controls:
+                self.controls["controls_width"].observe(
                     self._handle_container_width_change, names="value"
                 )
 
+            if "update_threshold" in self.controls:
+                self.controls["update_threshold"].observe(
+                    self._handle_update_threshold_change, names="value"
+                )
+
             widgets_elements = [param_box, layout_box]
         else:
             widgets_elements = [param_box]
@@ -287,8 +187,8 @@ class NotebookDeployer:
             widgets_elements,
             layout=widgets.Layout(
                 width=(
-                    f"{self.config.controls_width_percent}%"
-                    if self.config.is_horizontal
+                    f"{self.controls_width_percent}%"
+                    if self.controls_position in ["left", "right"]
                     else "100%"
                 ),
                 padding="10px",
@@ -303,8 +203,8 @@ class NotebookDeployer:
             [self.plot_output],
             layout=widgets.Layout(
                 width=(
-                    f"{100 - self.config.controls_width_percent}%"
-                    if self.config.is_horizontal
+                    f"{100 - self.controls_width_percent}%"
+                    if self.controls_position in ["left", "right"]
                     else "100%"
                 ),
                 padding="10px",
@@ -312,29 +212,114 @@ class NotebookDeployer:
         )
 
         # Create final layout based on configuration
-        if self.config.controls_position == "left":
-            return widgets.HBox([self.widgets_container, self.plot_container])
-        elif self.config.controls_position == "right":
-            return widgets.HBox([self.plot_container, self.widgets_container])
-        elif self.config.controls_position == "bottom":
-            return widgets.VBox([self.plot_container, self.widgets_container])
+        if self.controls_position == "left":
+            self.layout = widgets.HBox([self.widgets_container, self.plot_container])
+        elif self.controls_position == "right":
+            self.layout = widgets.HBox([self.plot_container, self.widgets_container])
+        elif self.controls_position == "bottom":
+            self.layout = widgets.VBox([self.plot_container, self.widgets_container])
         else:
-            return widgets.VBox([self.widgets_container, self.plot_container])
+            self.layout = widgets.VBox([self.widgets_container, self.plot_container])
 
-    def deploy(self) -> None:
-        """Deploy the interactive viewer with proper state management."""
-        self.backend_type = get_backend_type()
+        self._update_status("Ready!")
 
-        # We used to use the deploy_app context, but notebook deployment works
-        # differently because it's asynchronous and this doesn't really behave
-        # as intended. (e.g. with self.viewer._deploy_app() ...)
+    def handle_component_engagement(self, name: str) -> None:
+        """Handle engagement with an interactive component."""
+        if self._updating:
+            print(
+                "Already updating -- there's a circular dependency!"
+                "This is probably caused by failing to disable callbacks for a parameter."
+                "It's a bug --- tell the developer on github issues please."
+            )
+            return
 
-        # Create widgets
-        self._create_parameter_widgets()
+        with self._perform_update():
+            self._update_status(f"Updating {name}")
+            # Optionally suppress warnings during parameter updates
+            with warnings.catch_warnings():
+                if self.suppress_warnings:
+                    warnings.filterwarnings("ignore", category=ParameterUpdateWarning)
 
-        # Create and display layout
-        self.layout = self._create_layout()
-        display(self.layout)
+                # Get the component
+                component = self.components[name]
+                if component.is_action:
+                    # If the component is an action, call the callback
+                    parameter = self.viewer.parameters[name]
+                    parameter.callback(self.viewer.state)
+                else:
+                    # Otherwise, update the parameter value
+                    self.viewer.set_parameter_value(name, component.value)
+
+                # Update any components that changed due to dependencies
+                self.sync_components_with_state()
+
+                # Update the plot
+                self.update_plot()
+
+    def sync_components_with_state(self, exclude: Optional[str] = None) -> None:
+        """Sync component values with viewer state."""
+        for name, parameter in self.viewer.parameters.items():
+            if name == exclude:
+                continue
+
+            component = self.components[name]
+            if not component.matches_parameter(parameter):
+                component.update_from_parameter(parameter)
+
+    def update_plot(self) -> None:
+        """Update the plot with current state."""
+        state = self.viewer.state
+
+        with plot_context():
+            figure = self.viewer.plot(state)
+
+        # Update components if plot function updated a parameter
+        self.sync_components_with_state()
+
+        self._display_figure(figure)
+
+        self._showing_new_figure = True
+
+    def _display_figure(self, figure: plt.Figure, store_figure: bool = True) -> None:
+        with self._display_lock:
+            # Close the last figure if it exists to keep matplotlib clean
+            if self._last_figure is not None:
+                plt.close(self._last_figure)
+
+            self.plot_output.clear_output(wait=True)
+            with self.plot_output:
+                if self.backend_type == "inline":
+                    display(figure)
+
+                    # Also required to make sure a second figure window isn't opened
+                    plt.close(figure)
+
+                elif self.backend_type == "widget":
+                    display(figure.canvas)
+
+                else:
+                    raise ValueError(f"Unsupported backend type: {self.backend_type}")
+
+            if store_figure:
+                self._last_figure = figure
+
+    def _handle_container_width_change(self, _) -> None:
+        """Handle changes to container width proportions."""
+        width_percent = self.controls["controls_width"].value
+        self.controls_width_percent = width_percent
+
+        # Update container widths
+        self.widgets_container.layout.width = f"{width_percent}%"
+        self.plot_container.layout.width = f"{100 - width_percent}%"
 
-        # Create initial plot
-        self._update_plot()
+    def _handle_update_threshold_change(self, _) -> None:
+        """Handle changes to update threshold."""
+        self.update_threshold = self.controls["update_threshold"].value
+
+    def _update_status(self, status: str) -> None:
+        """Update the status text."""
+        value = "<b>Syd Controls</b>  "
+        value += "<span style='background-color: #e0e0e0; color: #000; padding: 2px 6px; border-radius: 4px; font-size: 90%;'>"
+        value += f"Status: {status}"
+        value += "</span>"
+        self.controls["status"].value = value

syd/notebook_deployment/widgets.py

@@ -31,7 +31,7 @@ class BaseWidget(Generic[T, W], ABC):
 
     _widget: W
     _callbacks: List[Dict[str, Union[Callable, Union[str, List[str]]]]]
-    _is_action: bool = False
+    is_action: bool = False
 
     def __init__(
         self,
@@ -465,7 +465,7 @@ class UnboundedFloatWidget(BaseWidget[UnboundedFloatParameter, widgets.FloatText
 class ButtonWidget(BaseWidget[ButtonAction, widgets.Button]):
     """Widget for button parameters."""
 
-    _is_action: bool = True
+    is_action: bool = True
 
     def _create_widget(
         self,