PyPI - syd - Versions diffs - 0.1.7__py3-none-any.whl → 1.0.0__py3-none-any.whl - Mend

syd 0.1.7py3-none-any.whl → 1.0.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

syd/__init__.py +1 -1
syd/flask_deployment/__init__.py +1 -1
syd/flask_deployment/deployer.py +563 -238
syd/flask_deployment/static/__init__.py +1 -0
syd/flask_deployment/static/css/styles.css +280 -0
syd/flask_deployment/static/js/viewer.js +795 -138
syd/flask_deployment/templates/__init__.py +1 -0
syd/flask_deployment/templates/index.html +34 -0
syd/flask_deployment/testing_principles.md +4 -4
syd/notebook_deployment/__init__.py +0 -1
syd/notebook_deployment/deployer.py +124 -213
syd/notebook_deployment/widgets.py +78 -60
syd/parameters.py +299 -345
syd/support.py +195 -0
syd/viewer.py +310 -347
syd-1.0.0.dist-info/METADATA +219 -0
syd-1.0.0.dist-info/RECORD +19 -0
syd/flask_deployment/components.py +0 -510
syd/flask_deployment/static/css/viewer.css +0 -82
syd/flask_deployment/templates/base.html +0 -29
syd/flask_deployment/templates/viewer.html +0 -51
syd/notebook_deployment/_ipympl_deployer.py +0 -258
syd/plotly_deployment/__init__.py +0 -1
syd/plotly_deployment/components.py +0 -531
syd/plotly_deployment/deployer.py +0 -376
syd-0.1.7.dist-info/METADATA +0 -120
syd-0.1.7.dist-info/RECORD +0 -22
{syd-0.1.7.dist-info → syd-1.0.0.dist-info}/WHEEL +0 -0
{syd-0.1.7.dist-info → syd-1.0.0.dist-info}/licenses/LICENSE +0 -0

syd/flask_deployment/templates/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ # This file exists to make the directory a proper Python package

syd/flask_deployment/templates/index.html ADDED Viewed

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>{{ title }}</title>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+</head>
+<body>
+    <div class="viewer-container" data-controls-position="{{ config.controls_position }}">
+        <div class="controls-container" data-width-percent="{{ config.controls_width_percent }}"
+             {% if config.is_horizontal %}style="width: {{ config.controls_width_percent }}%;"{% else %}style="height: {{ config.controls_width_percent }}%;"{% endif %}>
+            <div id="controls-container">
+                <!-- Controls will be dynamically generated via JavaScript -->
+            </div>
+        </div>
+        <div class="plot-container"
+             {% if config.is_horizontal %}style="width: calc(100% - {{ config.controls_width_percent }}%);"{% else %}style="height: calc(100% - {{ config.controls_width_percent }}%);"{% endif %}>
+            <img id="plot-image" width="100%" height="100%">
+        </div>
+    </div>
+    <!-- Store config as data attributes for JS to access -->
+    <div id="viewer-config"
+         data-figure-width="{{ config.figure_width }}"
+         data-figure-height="{{ config.figure_height }}"
+         data-controls-position="{{ config.controls_position }}"
+         data-controls-width-percent="{{ config.controls_width_percent }}"
+         style="display:none;"></div>
+    <script src="{{ url_for('static', filename='js/viewer.js') }}"></script>
+</body>
+</html>

syd/flask_deployment/testing_principles.md CHANGED Viewed

@@ -57,7 +57,7 @@ class TestFlaskDeployerComponents(unittest.TestCase):
 def test_parameter_update_state_sync():
     # Create real viewer with test parameters
     viewer = Viewer()
-    viewer.add_float('test_param', value=1.0, min_value=0, max_value=10)
+    viewer.add_float('test_param', value=1.0, min=0, max=10)
     # Create deployer with this viewer
     deployer = FlaskDeployer(viewer)
@@ -82,7 +82,7 @@ def test_parameter_update_state_sync():
 ```python
 def test_update_parameter_endpoint():
     viewer = Viewer()
-    viewer.add_float('test_param', value=1.0, min_value=0, max_value=10)
+    viewer.add_float('test_param', value=1.0, min=0, max=10)
     deployer = FlaskDeployer(viewer)
     app = deployer.app
@@ -218,8 +218,8 @@ def standard_test_viewer():
         return fig
     viewer.set_plot(plot)
-    viewer.add_float('amplitude', value=1.0, min_value=0, max_value=2)
-    viewer.add_float('frequency', value=1.0, min_value=0.1, max_value=5)
+    viewer.add_float('amplitude', value=1.0, min=0, max=2)
+    viewer.add_float('frequency', value=1.0, min=0.1, max=5)
     return viewer

syd/notebook_deployment/__init__.py CHANGED Viewed

	@@ -1 +0,0 @@
1	- from .deployer import NotebookDeployer

syd/notebook_deployment/deployer.py CHANGED Viewed

@@ -1,27 +1,13 @@
-from typing import Dict, Any, Optional
+from typing import Literal, Optional
 import warnings
-from functools import wraps
-from dataclasses import dataclass
-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 +26,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 = 30
-    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,74 +35,127 @@ class NotebookDeployer:
     def __init__(
         self,
         viewer: Viewer,
-        controls_position: str = "left",
-        figure_width: float = 8.0,
-        figure_height: float = 6.0,
-        controls_width_percent: int = 30,
+        controls_position: Literal["left", "top", "right", "bottom"] = "left",
+        controls_width_percent: int = 20,
         continuous: bool = False,
-        suppress_warnings: bool = False,
+        suppress_warnings: bool = True,
     ):
         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(
-                "The current backend is not supported. Please use %matplotlib widget or %matplotlib inline.\n"
-                "The behavior of the viewer will almost definitely not work as expected."
+                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!"
             )
-        self.parameter_widgets: Dict[str, BaseWidget] = {}
-        self.plot_output = widgets.Output()
+        self._last_figure = None
-        # Create layout for controls
-        self.layout_widgets = self._create_layout_controls()
+    def deploy(self) -> None:
+        """Deploy the viewer."""
+        self.build_components()
+        self.build_layout()
+        self.backend_type = get_backend_type()
+        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,
-                min=20,
-                max=80,
+        self.controls = {}
+        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 %",
                 continuous=True,
                 layout=widgets.Layout(width="95%"),
                 style={"description_width": "initial"},
             )
-        return controls
+        # Create parameter controls section
+        param_box = widgets.VBox(
+            [widgets.HTML("<b>Parameters</b>")]
+            + [w.widget for w in self.components.values()],
+            layout=widgets.Layout(margin="10px 0px"),
+        )
-    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,
+        # Combine all controls
+        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>Syd Controls</b>")] + list(self.controls.values()),
+                layout=widgets.Layout(margin="10px 0px"),
             )
-            # Store in widget dict
-            self.parameter_widgets[name] = widget
+            # Register the controls_width slider's observer
+            if "controls_width" in self.controls:
+                self.controls["controls_width"].observe(
+                    self._handle_container_width_change, names="value"
+                )
+            widgets_elements = [param_box, layout_box]
+        else:
+            widgets_elements = [param_box]
+        self.widgets_container = widgets.VBox(
+            widgets_elements,
+            layout=widgets.Layout(
+                width=(
+                    f"{self.controls_width_percent}%"
+                    if self.controls_position in ["left", "right"]
+                    else "100%"
+                ),
+                padding="10px",
+                overflow_y="scroll",
+                border="1px solid #e5e7eb",
+                border_radius="4px 4px 0px 0px",
+            ),
+        )
+        # Create plot container
+        self.plot_container = widgets.VBox(
+            [self.plot_output],
+            layout=widgets.Layout(
+                width=(
+                    f"{100 - self.controls_width_percent}%"
+                    if self.controls_position in ["left", "right"]
+                    else "100%"
+                ),
+                padding="10px",
+            ),
+        )
+        # Create final layout based on configuration
+        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:
+            self.layout = widgets.VBox([self.widgets_container, self.plot_container])
-    @debounce(0.1)
-    def _handle_widget_engagement(self, name: str) -> None:
-        """Handle engagement with an interactive widget."""
+    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!"
@@ -174,61 +172,46 @@ class NotebookDeployer:
                 if self.suppress_warnings:
                     warnings.filterwarnings("ignore", category=ParameterUpdateWarning)
-                widget = self.parameter_widgets[name]
-                if widget._is_action:
+                # 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:
-                    self.viewer.set_parameter_value(name, widget.value)
+                    # Otherwise, update the parameter value
+                    self.viewer.set_parameter_value(name, component.value)
-                # Update any widgets that changed due to dependencies
-                self._sync_widgets_with_state()
+                # Update any components that changed due to dependencies
+                self.sync_components_with_state()
                 # Update the plot
-                self._update_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."""
+    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
-            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
+            component = self.components[name]
+            if not component.matches_parameter(parameter):
+                component.update_from_parameter(parameter)
-        # 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:
+    def update_plot(self) -> None:
         """Update the plot with current state."""
         state = self.viewer.state
-        with _plot_context():
+        with plot_context():
             figure = self.viewer.plot(state)
+        # Update components if plot function updated a parameter
+        self.sync_components_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)
@@ -248,83 +231,11 @@ class NotebookDeployer:
         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()],
-            layout=widgets.Layout(margin="10px 0px"),
-        )
-        # Combine all controls
-        if self.config.is_horizontal:
-            # 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()),
-                layout=widgets.Layout(margin="10px 0px"),
-            )
-            widgets_elements = [param_box, layout_box]
-        else:
-            widgets_elements = [param_box]
-        self.widgets_container = widgets.VBox(
-            widgets_elements,
-            layout=widgets.Layout(
-                width=(
-                    f"{self.config.controls_width_percent}%"
-                    if self.config.is_horizontal
-                    else "100%"
-                ),
-                padding="10px",
-                overflow_y="scroll",
-                border="1px solid #e5e7eb",
-                border_radius="4px 4px 0px 0px",
-            ),
-        )
-        # Create plot container
-        self.plot_container = widgets.VBox(
-            [self.plot_output],
-            layout=widgets.Layout(
-                width=(
-                    f"{100 - self.config.controls_width_percent}%"
-                    if self.config.is_horizontal
-                    else "100%"
-                ),
-                padding="10px",
-            ),
-        )
-        # 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])
-        else:
-            return 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()
-        # 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() ...)
-        # Create widgets
-        self._create_parameter_widgets()
-        # Create and display layout
-        self.layout = self._create_layout()
-        display(self.layout)
+    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
-        # Create initial plot
-        self._update_plot()
+        # Update container widths
+        self.widgets_container.layout.width = f"{width_percent}%"
+        self.plot_container.layout.width = f"{100 - width_percent}%"

syd 0.1.7__py3-none-any.whl → 1.0.0__py3-none-any.whl

syd 0.1.7py3-none-any.whl → 1.0.0py3-none-any.whl