syd 0.1.0__py3-none-any.whl

syd/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

syd/interactive_viewer.py

@@ -0,0 +1,213 @@
+from typing import List, Any, Callable, Dict
+from functools import wraps
+from contextlib import contextmanager
+from matplotlib.figure import Figure
+
+from .parameters import ParameterType, Parameter
+
+
+def validate_parameter_operation(operation: str, parameter_type: ParameterType) -> Callable:
+    """
+    Decorator that validates parameter operations for the InteractiveViewer class.
+
+    This decorator ensures that:
+    1. The operation type matches the method name (add/update)
+    2. The parameter type matches the method's intended parameter type
+    3. Parameters can only be added when the app is not deployed
+    4. Parameters can only be updated when the app is deployed
+    5. For updates, validates that the parameter exists and is of the correct type
+
+    Args:
+        operation (str): The type of operation to validate. Must be either 'add' or 'update'.
+        parameter_type (ParameterType): The expected parameter type from the ParameterType enum.
+
+    Returns:
+        Callable: A decorated function that includes parameter validation.
+
+    Raises:
+        ValueError: If the operation type doesn't match the method name or if updating a non-existent parameter
+        TypeError: If updating a parameter with an incorrect type
+        RuntimeError: If adding parameters while deployed or updating while not deployed
+
+    Example:
+        @validate_parameter_operation('add', ParameterType.text)
+        def add_text(self, name: str, default: str = "") -> None:
+            ...
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(self: "InteractiveViewer", name: str, *args, **kwargs):
+            # Validate operation matches method name (add/update)
+            if not func.__name__.startswith(operation):
+                raise ValueError(f"Invalid operation type specified ({operation}) for method {func.__name__}")
+
+            # Validate deployment state
+            if operation == "add" and self._app_deployed:
+                raise RuntimeError("The app is currently deployed, cannot add a new parameter right now.")
+
+            # For updates, validate parameter existence and type
+            if operation == "update":
+                if name not in self.parameters:
+                    raise ValueError(f"Parameter called {name} not found - you can only update registered parameters!")
+                if type(self.parameters[name]) != parameter_type:
+                    msg = f"Parameter called {name} was found but is registered as a different parameter type ({type(self.parameters[name])})"
+                    raise TypeError(msg)
+
+            return func(self, name, *args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+class InteractiveViewer:
+    def __new__(cls):
+        instance = super().__new__(cls)
+        instance.parameters = {}
+        instance.callbacks = {}
+        instance.state = {}
+        instance._app_deployed = False
+        return instance
+
+    def __init__(self):
+        self.parameters: Dict[str, Parameter] = {}
+        self.callbacks: Dict[str, List[Callable]] = {}
+        self.state = {}
+        self._app_deployed = False
+
+    def param_dict(self) -> Dict[str, Any]:
+        return {name: param.value for name, param in self.parameters.items()}
+
+    def plot(self, **kwargs) -> Figure:
+        raise NotImplementedError("Subclasses must implement the plot method")
+
+    @contextmanager
+    def deploy_app(self):
+        """Internal context manager to control app deployment state"""
+        self._app_deployed = True
+        try:
+            yield
+        finally:
+            self._app_deployed = False
+
+    def perform_callbacks(self, name: str) -> bool:
+        """Perform callbacks for all parameters that have changed"""
+        if name in self.callbacks:
+            for callback in self.callbacks[name]:
+                callback(self.parameters[name].value)
+
+    def on_change(self, parameter_name: str, callback: Callable):
+        """Register a function to be called when a parameter changes."""
+        if parameter_name not in self.parameters:
+            raise ValueError(f"Parameter '{parameter_name}' is not registered!")
+        if parameter_name not in self.callbacks:
+            self.callbacks[parameter_name] = []
+        self.callbacks[parameter_name].append(callback)
+
+    def set_parameter_value(self, name: str, value: Any) -> None:
+        """Set a parameter value and trigger dependency updates"""
+        if name not in self.parameters:
+            raise ValueError(f"Parameter {name} not found")
+
+        # Update the parameter value
+        self.parameters[name].value = value
+
+        # Perform callbacks
+        self.perform_callbacks(name)
+
+    # -------------------- parameter registration methods --------------------
+    @validate_parameter_operation("add", ParameterType.text)
+    def add_text(self, name: str, default: str = "") -> None:
+        self.parameters[name] = ParameterType.text.value(name, default)
+
+    @validate_parameter_operation("add", ParameterType.selection)
+    def add_selection(self, name: str, options: List[Any], default: str = None) -> None:
+        self.parameters[name] = ParameterType.selection.value(name, options, default)
+
+    @validate_parameter_operation("add", ParameterType.multiple_selection)
+    def add_multiple_selection(self, name: str, options: List[Any], defaults: List[Any] = None) -> None:
+        self.parameters[name] = ParameterType.multiple_selection.value(name, options, defaults)
+
+    @validate_parameter_operation("add", ParameterType.boolean)
+    def add_boolean(self, name: str, default: bool = False) -> None:
+        self.parameters[name] = ParameterType.boolean.value(name, default)
+
+    @validate_parameter_operation("add", ParameterType.integer)
+    def add_integer(self, name: str, min_value: int, max_value: int, default: int = None) -> None:
+        self.parameters[name] = ParameterType.integer.value(name, min_value, max_value, default)
+
+    @validate_parameter_operation("add", ParameterType.float)
+    def add_float(self, name: str, min_value: float, max_value: float, step: float = 0.1, default: float = None) -> None:
+        self.parameters[name] = ParameterType.float.value(name, min_value, max_value, step, default)
+
+    @validate_parameter_operation("add", ParameterType.integer_pair)
+    def add_integer_pair(
+        self,
+        name: str,
+        min_value: int,
+        max_value: int,
+        default_low: int = None,
+        default_high: int = None,
+    ) -> None:
+        self.parameters[name] = ParameterType.integer_pair.value(name, min_value, max_value, default_low, default_high)
+
+    @validate_parameter_operation("add", ParameterType.float_pair)
+    def add_float_pair(
+        self,
+        name: str,
+        min_value: float,
+        max_value: float,
+        step: float = 0.1,
+        default_low: float = None,
+        default_high: float = None,
+    ) -> None:
+        self.parameters[name] = ParameterType.float_pair.value(name, min_value, max_value, step, default_low, default_high)
+
+    # -------------------- parameter update methods --------------------
+    @validate_parameter_operation("update", ParameterType.text)
+    def update_text(self, name: str, default: str = "") -> None:
+        self.parameters[name] = ParameterType.text.value(name, default)
+
+    @validate_parameter_operation("update", ParameterType.selection)
+    def update_selection(self, name: str, options: List[Any], default: str = None) -> None:
+        self.parameters[name] = ParameterType.selection.value(name, options, default)
+
+    @validate_parameter_operation("update", ParameterType.multiple_selection)
+    def update_multiple_selection(self, name: str, options: List[Any], defaults: List[Any] = None) -> None:
+        self.parameters[name] = ParameterType.multiple_selection.value(name, options, defaults)
+
+    @validate_parameter_operation("update", ParameterType.boolean)
+    def update_boolean(self, name: str, default: bool = False) -> None:
+        self.parameters[name] = ParameterType.boolean.value(name, default)
+
+    @validate_parameter_operation("update", ParameterType.integer)
+    def update_integer(self, name: str, min_value: int, max_value: int, default: int = None) -> None:
+        self.parameters[name] = ParameterType.integer.value(name, min_value, max_value, default)
+
+    @validate_parameter_operation("update", ParameterType.float)
+    def update_float(self, name: str, min_value: float, max_value: float, step: float = 0.1, default: float = None) -> None:
+        self.parameters[name] = ParameterType.float.value(name, min_value, max_value, step, default)
+
+    @validate_parameter_operation("update", ParameterType.integer_pair)
+    def update_integer_pair(
+        self,
+        name: str,
+        min_value: int,
+        max_value: int,
+        default_low: int = None,
+        default_high: int = None,
+    ) -> None:
+        self.parameters[name] = ParameterType.integer_pair.value(name, min_value, max_value, default_low, default_high)
+
+    @validate_parameter_operation("update", ParameterType.float_pair)
+    def update_float_pair(
+        self,
+        name: str,
+        min_value: float,
+        max_value: float,
+        step: float = 0.1,
+        default_low: float = None,
+        default_high: float = None,
+    ) -> None:
+        self.parameters[name] = ParameterType.float_pair.value(name, min_value, max_value, step, default_low, default_high)

syd/notebook_deploy.py

@@ -0,0 +1,270 @@
+from typing import Dict, Any
+import matplotlib.pyplot as plt
+import ipywidgets as widgets
+from IPython.display import display
+from .parameters import (
+    Parameter,
+    TextParameter,
+    SingleSelectionParameter,
+    MultipleSelectionParameter,
+    BooleanParameter,
+    IntegerParameter,
+    FloatParameter,
+    IntegerPairParameter,
+    FloatPairParameter,
+)
+from .interactive_viewer import InteractiveViewer
+
+
+class NotebookDeployment:
+    """
+    Deployment system for InteractiveViewer in Jupyter notebooks using ipywidgets.
+    Includes enhanced layout control and figure size management.
+    """
+
+    def __init__(self, viewer: InteractiveViewer):
+        """Initialize with an InteractiveViewer instance."""
+        self.viewer = viewer
+        self.widgets: Dict[str, widgets.Widget] = {}
+        self._widget_callbacks = {}
+        self._current_figure = None
+
+        # Default figure size
+        self.fig_width = 8
+        self.fig_height = 6
+
+    def _create_text_widget(self, param: TextParameter) -> widgets.Text:
+        """Create a text input widget."""
+        w = widgets.Text(value=param.default, description=param.name, layout=widgets.Layout(width="95%"), style={"description_width": "initial"})
+        return w
+
+    def _create_selection_widget(self, param: SingleSelectionParameter) -> widgets.Dropdown:
+        """Create a dropdown selection widget."""
+        w = widgets.Dropdown(
+            options=param.options,
+            value=param.default if param.default else param.options[0],
+            description=param.name,
+            layout=widgets.Layout(width="95%"),
+            style={"description_width": "initial"},
+        )
+        return w
+
+    def _create_multiple_selection_widget(self, param: MultipleSelectionParameter) -> widgets.SelectMultiple:
+        """Create a multiple selection widget."""
+        w = widgets.SelectMultiple(
+            options=param.options,
+            value=param.default if param.default else [],
+            description=param.name,
+            layout=widgets.Layout(width="95%"),
+            style={"description_width": "initial"},
+        )
+        return w
+
+    def _create_boolean_widget(self, param: BooleanParameter) -> widgets.Checkbox:
+        """Create a checkbox widget."""
+        w = widgets.Checkbox(value=param.default, description=param.name, layout=widgets.Layout(width="95%"), style={"description_width": "initial"})
+        return w
+
+    def _create_integer_widget(self, param: IntegerParameter) -> widgets.IntSlider:
+        """Create an integer slider widget."""
+        w = widgets.IntSlider(
+            value=param.default if param.default is not None else param.min_value,
+            min=param.min_value,
+            max=param.max_value,
+            description=param.name,
+            layout=widgets.Layout(width="95%"),
+            style={"description_width": "initial"},
+        )
+        return w
+
+    def _create_float_widget(self, param: FloatParameter) -> widgets.FloatSlider:
+        """Create a float slider widget."""
+        w = widgets.FloatSlider(
+            value=param.default if param.default is not None else param.min_value,
+            min=param.min_value,
+            max=param.max_value,
+            step=param.step,
+            description=param.name,
+            layout=widgets.Layout(width="95%"),
+            style={"description_width": "initial"},
+        )
+        return w
+
+    def _create_integer_pair_widget(self, param: IntegerPairParameter) -> widgets.HBox:
+        """Create a pair of integer input widgets."""
+        low = widgets.IntText(
+            value=param.default_low if param.default_low is not None else param.min_value,
+            description=f"{param.name} (low)",
+            layout=widgets.Layout(width="47%"),
+            style={"description_width": "initial"},
+        )
+        high = widgets.IntText(
+            value=param.default_high if param.default_high is not None else param.max_value,
+            description=f"{param.name} (high)",
+            layout=widgets.Layout(width="47%"),
+            style={"description_width": "initial"},
+        )
+        return widgets.HBox([low, high], layout=widgets.Layout(width="95%"))
+
+    def _create_float_pair_widget(self, param: FloatPairParameter) -> widgets.HBox:
+        """Create a pair of float input widgets."""
+        low = widgets.FloatText(
+            value=param.default_low if param.default_low is not None else param.min_value,
+            description=f"{param.name} (low)",
+            layout=widgets.Layout(width="47%"),
+            style={"description_width": "initial"},
+        )
+        high = widgets.FloatText(
+            value=param.default_high if param.default_high is not None else param.max_value,
+            description=f"{param.name} (high)",
+            layout=widgets.Layout(width="47%"),
+            style={"description_width": "initial"},
+        )
+        return widgets.HBox([low, high], layout=widgets.Layout(width="95%"))
+
+    def _create_widget_for_parameter(self, param: Parameter) -> widgets.Widget:
+        """Create the appropriate widget based on parameter type."""
+        widget_creators = {
+            TextParameter: self._create_text_widget,
+            SingleSelectionParameter: self._create_selection_widget,
+            MultipleSelectionParameter: self._create_multiple_selection_widget,
+            BooleanParameter: self._create_boolean_widget,
+            IntegerParameter: self._create_integer_widget,
+            FloatParameter: self._create_float_widget,
+            IntegerPairParameter: self._create_integer_pair_widget,
+            FloatPairParameter: self._create_float_pair_widget,
+        }
+
+        creator = widget_creators.get(type(param))
+        if not creator:
+            raise ValueError(f"Unsupported parameter type: {type(param)}")
+
+        return creator(param)
+
+    def _create_size_controls(self) -> widgets.VBox:
+        """Create controls for adjusting the figure size."""
+        self.width_slider = widgets.FloatSlider(
+            value=self.fig_width,
+            min=4,
+            max=20,
+            step=0.5,
+            description="Figure Width",
+            layout=widgets.Layout(width="95%"),
+            style={"description_width": "initial"},
+        )
+
+        self.height_slider = widgets.FloatSlider(
+            value=self.fig_height,
+            min=3,
+            max=15,
+            step=0.5,
+            description="Figure Height",
+            layout=widgets.Layout(width="95%"),
+            style={"description_width": "initial"},
+        )
+
+        self.container_width = widgets.IntSlider(
+            value=30,
+            min=20,
+            max=80,
+            description="Controls Width %",
+            layout=widgets.Layout(width="95%"),
+            style={"description_width": "initial"},
+        )
+
+        # Add callbacks for size changes
+        self.width_slider.observe(self._handle_size_change, names="value")
+        self.height_slider.observe(self._handle_size_change, names="value")
+        self.container_width.observe(self._handle_container_width_change, names="value")
+
+        return widgets.VBox(
+            [widgets.HTML("<b>Layout Controls</b>"), self.width_slider, self.height_slider, self.container_width],
+            layout=widgets.Layout(margin="10px 0px"),
+        )
+
+    def _handle_size_change(self, change: Dict[str, Any]) -> None:
+        """Handle changes to figure size."""
+        self.fig_width = self.width_slider.value
+        self.fig_height = self.height_slider.value
+        self._update_plot()
+
+    def _handle_container_width_change(self, change: Dict[str, Any]) -> None:
+        """Handle changes to container widths."""
+        controls_width = f"{self.container_width.value}%"
+        plot_width = f"{100 - self.container_width.value}%"
+
+        self.widgets_container.layout.width = controls_width
+        self.plot_container.layout.width = plot_width
+
+    def _handle_widget_change(self, name: str, change: Dict[str, Any]) -> None:
+        """Handle widget value changes and update the viewer parameter."""
+        if isinstance(self.widgets[name], widgets.HBox):
+            # Handle pair widgets
+            low_value = self.widgets[name].children[0].value
+            high_value = self.widgets[name].children[1].value
+            value = (low_value, high_value)
+        else:
+            value = change["new"]
+
+        self.viewer.set_parameter_value(name, value)
+        self._update_plot()
+
+    def _update_plot(self) -> None:
+        """Update the plot with current parameters and size."""
+        self._current_fig.clear()
+        self._current_fig.set_size_inches(self.fig_width, self.fig_height)
+        self._current_fig = self.viewer.plot(fig=self._current_fig, state=self.viewer.param_dict())
+
+        # Apply tight layout to remove dead space
+        self._current_fig.tight_layout()
+
+        self.plot_output.clear_output(wait=True)
+        with self.plot_output:
+            display(self._current_fig)
+
+    def create_widgets(self) -> None:
+        """Create widgets for all parameters in the viewer."""
+        for name, param in self.viewer.parameters.items():
+            widget = self._create_widget_for_parameter(param)
+            self.widgets[name] = widget
+
+            # Set up callback
+            if isinstance(widget, widgets.HBox):
+                # For pair widgets, observe both components
+                widget.children[0].observe(lambda change, n=name: self._handle_widget_change(n, change), names="value")
+                widget.children[1].observe(lambda change, n=name: self._handle_widget_change(n, change), names="value")
+            else:
+                widget.observe(lambda change, n=name: self._handle_widget_change(n, change), names="value")
+
+    def display_widgets(self) -> None:
+        """Display all widgets and plot in an organized layout."""
+        # Create size controls
+        size_controls = self._create_size_controls()
+
+        # Create widgets container with parameters and size controls
+        all_widgets = list(self.widgets.values()) + [size_controls]
+        self.widgets_container = widgets.VBox(all_widgets, layout=widgets.Layout(width="30%", padding="10px", overflow_y="auto"))
+
+        # Create output widget for plot
+        self.plot_output = widgets.Output()
+        self.plot_container = widgets.VBox([self.plot_output], layout=widgets.Layout(width="70%", padding="10px"))
+
+        # Combine widgets and plot in layout
+        # Make the container height dynamic
+        layout = widgets.HBox(
+            [self.widgets_container, self.plot_container], layout=widgets.Layout(width="100%", height="auto")  # Dynamic height based on content
+        )
+        display(layout)
+
+        # Create initial plot
+        self._current_fig = plt.figure(figsize=(self.fig_width, self.fig_height))
+        plt.close(self._current_fig)  # close the figure to prevent it from being displayed
+        self._current_fig = self.viewer.plot(fig=self._current_fig, state=self.viewer.param_dict())
+        with self.plot_output:
+            display(self._current_fig)
+
+    def deploy(self) -> None:
+        """Create and display all widgets with proper deployment state management."""
+        with self.viewer.deploy_app():
+            self.create_widgets()
+            self.display_widgets()