PyPI - syd - Versions diffs - 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl - Mend

syd 0.1.6py3-none-any.whl → 0.2.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 (25) hide show

syd/__init__.py +3 -3
syd/flask_deployment/__init__.py +7 -0
syd/flask_deployment/deployer.py +594 -291
syd/flask_deployment/static/__init__.py +1 -0
syd/flask_deployment/static/css/styles.css +226 -19
syd/flask_deployment/static/js/viewer.js +744 -0
syd/flask_deployment/templates/__init__.py +1 -0
syd/flask_deployment/templates/index.html +34 -0
syd/flask_deployment/testing_principles.md +300 -0
syd/notebook_deployment/__init__.py +1 -1
syd/notebook_deployment/deployer.py +139 -53
syd/notebook_deployment/widgets.py +214 -123
syd/parameters.py +295 -393
syd/support.py +168 -0
syd/{interactive_viewer.py → viewer.py} +393 -470
syd-0.2.0.dist-info/METADATA +126 -0
syd-0.2.0.dist-info/RECORD +19 -0
syd/flask_deployment/components.py +0 -497
syd/flask_deployment/static/js/components.js +0 -51
syd/flask_deployment/templates/base.html +0 -26
syd/flask_deployment/templates/viewer.html +0 -97
syd-0.1.6.dist-info/METADATA +0 -106
syd-0.1.6.dist-info/RECORD +0 -18
{syd-0.1.6.dist-info → syd-0.2.0.dist-info}/WHEEL +0 -0
{syd-0.1.6.dist-info → syd-0.2.0.dist-info}/licenses/LICENSE +0 -0

syd/flask_deployment/deployer.py CHANGED Viewed

@@ -1,133 +1,92 @@
-from typing import Dict, Any, Optional
-from dataclasses import dataclass
-import threading
-from flask import Flask, render_template_string, jsonify, request
-import matplotlib
+"""
+Flask deployer for Syd Viewer objects.
+This module provides tools to deploy Syd viewers as Flask web applications.
+"""
-matplotlib.use("Agg")  # Use Agg backend for thread safety
+import os
+import json
+import logging
+from typing import Dict, Any, Optional, List, Union, Callable, Type
+from dataclasses import dataclass
+from contextlib import contextmanager
+import matplotlib as mpl
 import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
 import io
-import base64
-from contextlib import contextmanager
+import numpy as np
+import time
+from functools import wraps
 import webbrowser
-from ..interactive_viewer import InteractiveViewer
-from .components import WebComponentCollection
-# Create a template constant to hold our HTML template
-PAGE_TEMPLATE = """
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Interactive Viewer</title>
-    {% for css in required_css %}
-    <link rel="stylesheet" href="{{ css }}">
-    {% endfor %}
-    <style>
-        {{ custom_styles | safe }}
-        .controls {
-            {% if config.is_horizontal %}
-            width: {{ config.controls_width_percent }}%;
-            float: left;
-            padding-right: 20px;
-            {% endif %}
-        }
-        .plot-container {
-            {% if config.is_horizontal %}
-            width: {{ 100 - config.controls_width_percent }}%;
-            float: left;
-            {% endif %}
-        }
-        #plot {
-            width: 100%;
-            height: auto;
-        }
-    </style>
-</head>
-<body>
-    <div class="container-fluid">
-        <div class="row">
-            <div class="controls">
-                {{ components_html | safe }}
-            </div>
-            <div class="plot-container">
-                <img id="plot" src="{{ initial_plot }}">
-            </div>
-        </div>
-    </div>
-    {% for js in required_js %}
-    <script src="{{ js }}"></script>
-    {% endfor %}
-    <script>
-        function updateParameter(name, value) {
-            fetch('/update_parameter', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({name, value})
-            })
-            .then(response => response.json())
-            .then(data => {
-                if (data.error) {
-                    console.error(data.error);
-                    return;
-                }
-                // Update plot
-                document.getElementById('plot').src = data.plot;
-                // Apply any parameter updates
-                for (const [param, js] of Object.entries(data.updates)) {
-                    eval(js);
-                }
-            });
-        }
-        function buttonClick(name) {
-            fetch('/button_click', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({name})
-            })
-            .then(response => response.json())
-            .then(data => {
-                if (data.error) {
-                    console.error(data.error);
-                    return;
-                }
-                // Update plot
-                document.getElementById('plot').src = data.plot;
-                // Apply any parameter updates
-                for (const [param, js] of Object.entries(data.updates)) {
-                    eval(js);
-                }
-            });
-        }
-        // Initialize components
-        {{ components_init | safe }}
-    </script>
-</body>
-</html>
-"""
+import threading
+import socket
+from flask import (
+    Flask,
+    send_file,
+    request,
+    make_response,
+    jsonify,
+    render_template,
+    url_for,
+)
+from werkzeug.serving import run_simple
+from ..viewer import Viewer
+from ..parameters import (
+    Parameter,
+    TextParameter,
+    BooleanParameter,
+    SelectionParameter,
+    MultipleSelectionParameter,
+    IntegerParameter,
+    FloatParameter,
+    IntegerRangeParameter,
+    FloatRangeParameter,
+    UnboundedIntegerParameter,
+    UnboundedFloatParameter,
+    ButtonAction,
+    ParameterType,
+    ActionType,
+)
+mpl.use("Agg")
+def debounce(wait_time=0.1):
+    """
+    Decorator to debounce function calls.
+    Prevents a function from being called too frequently.
+    """
+    def decorator(fn):
+        last_call_time = [0]
+        @wraps(fn)
+        def debounced(*args, **kwargs):
+            current_time = time.time()
+            if current_time - last_call_time[0] > wait_time:
+                last_call_time[0] = current_time
+                return fn(*args, **kwargs)
+            return None
+        return debounced
+    return decorator
 @dataclass
 class FlaskLayoutConfig:
-    """Configuration for the viewer layout in Flask deployment."""
+    """Configuration for the Flask viewer layout."""
-    controls_position: str = "left"  # Options are: 'left', 'top'
+    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
-    port: int = 5000
-    host: str = "localhost"
     def __post_init__(self):
-        valid_positions = ["left", "top"]
+        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}"
@@ -135,204 +94,548 @@ class FlaskLayoutConfig:
     @property
     def is_horizontal(self) -> bool:
-        return self.controls_position == "left"
+        return self.controls_position == "left" or self.controls_position == "right"
-class FlaskDeployment:
-    """A deployment system for InteractiveViewer using Flask to create a web interface."""
+class FlaskDeployer:
+    """
+    A deployment system for Viewer as a Flask web application.
+    Creates a Flask app with routes for the UI, data API, and plot generation.
+    """
     def __init__(
         self,
-        viewer: InteractiveViewer,
-        layout_config: Optional[FlaskLayoutConfig] = None,
+        viewer: Viewer,
+        controls_position: str = "left",
+        fig_dpi: int = 300,
+        figure_width: float = 8.0,
+        figure_height: float = 6.0,
+        controls_width_percent: int = 30,
+        static_folder: Optional[str] = None,
+        template_folder: Optional[str] = None,
+        debug: bool = False,
     ):
-        if not isinstance(viewer, InteractiveViewer):
-            raise TypeError(
-                f"viewer must be an InteractiveViewer, got {type(viewer).__name__}"
-            )
+        """
+        Initialize the Flask deployer.
+        Parameters
+        ----------
+        viewer : Viewer
+            The viewer to deploy
+        controls_position : str, optional
+            Position of the controls ('left', 'top', 'right', 'bottom')
+        fig_dpi : int, optional
+            DPI of the figure - higher is better quality but takes longer to generate
+        figure_width : float, optional
+            Width of the figure in inches
+        figure_height : float, optional
+            Height of the figure in inches
+        controls_width_percent : int, optional
+            Width of the controls as a percentage of the total width
+        static_folder : str, optional
+            Custom path to static files
+        template_folder : str, optional
+            Custom path to template files
+        debug : bool, optional
+            Whether to enable debug mode
+        """
         self.viewer = viewer
-        self.config = layout_config or FlaskLayoutConfig()
-        self.components = WebComponentCollection()
-        # Initialize Flask app
-        self.app = Flask(__name__)
-        self._setup_routes()
+        self.config = FlaskLayoutConfig(
+            controls_position=controls_position,
+            figure_width=figure_width,
+            figure_height=figure_height,
+            controls_width_percent=controls_width_percent,
+        )
+        self.fig_dpi = fig_dpi
+        self.debug = debug
+        # Use default folders if not specified
+        package_dir = os.path.dirname(os.path.abspath(__file__))
+        self.static_folder = static_folder or os.path.join(package_dir, "static")
+        self.template_folder = template_folder or os.path.join(package_dir, "templates")
+        # State tracking
+        self.in_callbacks = False
+        # Create Flask app
+        self.app = self.create_app()
+    def create_app(self) -> Flask:
+        """
+        Create and configure the Flask application.
+        Returns
+        -------
+        Flask
+            The configured Flask application
+        """
+        app = Flask(
+            __name__,
+            static_folder=self.static_folder,
+            template_folder=self.template_folder,
+        )
-        # Store current figure
-        self._current_figure = None
-        self._figure_lock = threading.Lock()
+        # Configure logging
+        if not self.debug:
+            log = logging.getLogger("werkzeug")
+            log.setLevel(logging.ERROR)
-    def _setup_routes(self):
-        """Set up the Flask routes for the application."""
+        # Define routes
-        @self.app.route("/")
-        def index():
-            return self._render_page()
+        @app.route("/")
+        def home():
+            """Render the main page."""
+            return render_template("index.html", config=self.config)
-        @self.app.route("/update_parameter", methods=["POST"])
-        def update_parameter():
-            data = request.json
-            name = data.get("name")
-            value = data.get("value")
+        @app.route("/init-data")
+        def init_data():
+            """Provide initial parameter information."""
+            param_info = {}
-            print(f"Received parameter update: {name} = {value}")  # Debug log
+            for name, param in self.viewer.parameters.items():
+                param_info[name] = self._get_parameter_info(param)
-            if name not in self.viewer.parameters:
-                print(f"Parameter {name} not found in viewer parameters")  # Debug log
-                return jsonify({"error": f"Parameter {name} not found"}), 404
+            return jsonify({"params": param_info})
+        @app.route("/plot")
+        def plot():
+            """Generate and return a plot based on the current state."""
             try:
-                print(f"Setting parameter value: {name} = {value}")  # Debug log
-                self.viewer.set_parameter_value(name, value)
-                # Update the plot with new parameter values
-                print("Updating plot with new parameters...")  # Debug log
-                self._update_plot()
-                updates = self._get_parameter_updates()
-                plot_data = self._get_current_plot_data()
-                # Debug log
-                print(f"Generated updates for parameters: {list(updates.keys())}")
-                return jsonify(
-                    {
-                        "success": True,
-                        "updates": updates,
-                        "plot": plot_data,
-                    }
-                )
-            except Exception as e:
-                print(f"Error updating parameter: {str(e)}")  # Debug log
-                return jsonify({"error": str(e)}), 400
+                # Get parameters from request
+                state = self._parse_request_args(request.args)
-        @self.app.route("/button_click", methods=["POST"])
-        def button_click():
-            data = request.json
-            name = data.get("name")
+                # Update viewer state
+                for name, value in state.items():
+                    if name in self.viewer.parameters:
+                        self.viewer.parameters[name].value = value
-            print(f"Received button click: {name}")  # Debug log
+                # Get the plot from the viewer
+                with _plot_context():
+                    fig = self.viewer.plot(self.viewer.state)
-            if name not in self.viewer.parameters:
-                print(f"Button {name} not found in viewer parameters")  # Debug log
-                return jsonify({"error": f"Parameter {name} not found"}), 404
+                # Save the plot to a buffer
+                buf = io.BytesIO()
+                fig.savefig(buf, format="png", bbox_inches="tight", dpi=self.fig_dpi)
+                buf.seek(0)
+                plt.close(fig)
+                # Return the image
+                response = make_response(send_file(buf, mimetype="image/png"))
+                response.headers["Cache-Control"] = "no-cache"
+                return response
+            except Exception as e:
+                app.logger.error(f"Error: {str(e)}")
+                return f"Error generating plot: {str(e)}", 500
+        @app.route("/update-param", methods=["POST"])
+        def update_param():
+            """Update a parameter and run its callbacks."""
             try:
-                parameter = self.viewer.parameters[name]
-                if hasattr(parameter, "callback"):
-                    print(f"Executing callback for button: {name}")  # Debug log
-                    parameter.callback(self.viewer.get_state())
+                data = request.get_json()
+                name = data.get("name")
+                value = data.get("value")
+                is_action = data.get("action", False)
+                if name not in self.viewer.parameters:
+                    return jsonify({"error": f"Parameter {name} not found"}), 404
+                # Handle the parameter update or action
+                if is_action:
+                    # For button actions, run the callback
+                    self._handle_action(name)
                 else:
-                    print(f"No callback found for button: {name}")  # Debug log
-                # Update the plot after button click
-                print("Updating plot after button click...")  # Debug log
-                self._update_plot()
-                updates = self._get_parameter_updates()
-                plot_data = self._get_current_plot_data()
-                # Debug log
-                print(f"Generated updates for parameters: {list(updates.keys())}")
-                return jsonify(
-                    {
-                        "success": True,
-                        "updates": updates,
-                        "plot": plot_data,
-                    }
-                )
+                    # For normal parameters, update value and run callbacks
+                    parsed_value = self._parse_parameter_value(name, value)
+                    self._handle_parameter_update(name, parsed_value)
+                # Return the updated state
+                return jsonify({"success": True, "state": self.viewer.state})
             except Exception as e:
-                print(f"Error handling button click: {str(e)}")  # Debug log
-                return jsonify({"error": str(e)}), 400
-    def _create_components(self):
-        """Create web components for all parameters."""
-        for name, param in self.viewer.parameters.items():
-            self.components.add_component(name, param)
-    @contextmanager
-    def _plot_context(self):
-        """Context manager for thread-safe plotting."""
-        plt.ioff()
+                app.logger.error(f"Error updating parameter: {str(e)}")
+                return jsonify({"error": str(e)}), 500
+        return app
+    @debounce(0.1)
+    def _handle_parameter_update(self, name: str, value: Any) -> None:
+        """
+        Handle a parameter update, including running callbacks.
+        Parameters
+        ----------
+        name : str
+            The name of the parameter to update
+        value : Any
+            The new value for the parameter
+        """
+        # Prevent recursive callback cycles
+        if self.in_callbacks:
+            return
         try:
-            yield
+            # Update the parameter value
+            self.viewer.parameters[name].value = value
+            # Run callbacks for this parameter
+            self.in_callbacks = True
+            # The viewer's perform_callbacks method will automatically
+            # pass the state dictionary to the callbacks
+            self.viewer.perform_callbacks(name)
         finally:
-            plt.ion()
-    def _update_plot(self) -> None:
-        """Update the plot with current state."""
-        state = self.viewer.get_state()
-        print(f"Updating plot with state: {state}")  # Debug log
-        with self._plot_context(), self._figure_lock:
-            new_fig = self.viewer.plot(state)
-            plt.close(self._current_figure)  # Close old figure
-            self._current_figure = new_fig
-            print("Plot updated successfully")  # Debug log
-    def _get_current_plot_data(self) -> str:
-        """Get the current plot as a base64 encoded PNG."""
-        with self._figure_lock:
-            if self._current_figure is None:
-                return ""
-            buffer = io.BytesIO()
-            self._current_figure.savefig(
-                buffer,
-                format="png",
-                bbox_inches="tight",
-                dpi=300,
-            )
-            buffer.seek(0)
-            image_png = buffer.getvalue()
-            buffer.close()
-            graphic = base64.b64encode(image_png).decode("utf-8")
-            return f"data:image/png;base64,{graphic}"
-    def _get_parameter_updates(self) -> Dict[str, Any]:
-        """Get JavaScript updates for all parameters."""
-        updates = {}
-        state = self.viewer.get_state()
-        for name, value in state.items():
-            # Skip button parameters since they don't have a meaningful value to update
-            if (
-                hasattr(self.viewer.parameters[name], "_is_button")
-                and self.viewer.parameters[name]._is_button
-            ):
+            self.in_callbacks = False
+    def _handle_action(self, name: str) -> None:
+        """
+        Handle a button action by executing its callback.
+        Parameters
+        ----------
+        name : str
+            The name of the button parameter
+        """
+        # Prevent recursive callback cycles
+        if self.in_callbacks:
+            return
+        try:
+            # Execute the button callback
+            param = self.viewer.parameters[name]
+            if isinstance(param, ButtonAction) and param.callback:
+                self.in_callbacks = True
+                # Pass the current state to the callback
+                param.callback(self.viewer.state)
+        finally:
+            self.in_callbacks = False
+    def _get_parameter_info(self, param: Parameter) -> Dict[str, Any]:
+        """
+        Convert a Parameter object to a dictionary of information for the frontend.
+        Parameters
+        ----------
+        param : Parameter
+            The parameter to convert
+        Returns
+        -------
+        Dict[str, Any]
+            Parameter information for the frontend
+        """
+        if isinstance(param, TextParameter):
+            return {"type": "text", "value": param.value}
+        elif isinstance(param, BooleanParameter):
+            return {"type": "boolean", "value": param.value}
+        elif isinstance(param, SelectionParameter):
+            return {"type": "selection", "value": param.value, "options": param.options}
+        elif isinstance(param, MultipleSelectionParameter):
+            return {
+                "type": "multiple-selection",
+                "value": param.value,
+                "options": param.options,
+            }
+        elif isinstance(param, IntegerParameter):
+            return {
+                "type": "integer",
+                "value": param.value,
+                "name": param.name,
+                "min": param.min,
+                "max": param.max,
+            }
+        elif isinstance(param, FloatParameter):
+            return {
+                "type": "float",
+                "value": param.value,
+                "name": param.name,
+                "min": param.min,
+                "max": param.max,
+                "step": param.step,
+            }
+        elif isinstance(param, IntegerRangeParameter):
+            return {
+                "type": "integer-range",
+                "value": param.value,
+                "name": param.name,
+                "min": param.min,
+                "max": param.max,
+            }
+        elif isinstance(param, FloatRangeParameter):
+            return {
+                "type": "float-range",
+                "value": param.value,
+                "name": param.name,
+                "min": param.min,
+                "max": param.max,
+                "step": param.step,
+            }
+        elif isinstance(param, UnboundedIntegerParameter):
+            return {"type": "unbounded-integer", "value": param.value}
+        elif isinstance(param, UnboundedFloatParameter):
+            return {"type": "unbounded-float", "value": param.value, "step": param.step}
+        elif isinstance(param, ButtonAction):
+            return {"type": "button", "label": param.label, "is_action": True}
+        else:
+            return {"type": "unknown", "value": str(param.value)}
+    def _parse_request_args(self, args) -> Dict[str, Any]:
+        """
+        Parse request arguments into appropriate Python types based on parameter types.
+        Parameters
+        ----------
+        args : MultiDict
+            Request arguments
+        Returns
+        -------
+        Dict[str, Any]
+            Parsed parameters
+        """
+        result = {}
+        for name, value in args.items():
+            # Skip if parameter doesn't exist
+            if name not in self.viewer.parameters:
                 continue
-            updates[name] = self.components.get_update_js(name, value)
-        return updates
-    def _render_page(self) -> str:
-        """Render the complete HTML page."""
-        # Create initial plot
-        self._update_plot()
-        return render_template_string(
-            PAGE_TEMPLATE,
-            config=self.config,
-            components_html=self.components.get_all_html(),
-            components_init=self.components.get_init_js(),
-            initial_plot=self._get_current_plot_data(),
-            required_css=self.components.get_required_css(),
-            required_js=self.components.get_required_js(),
-            custom_styles=self.components.get_custom_styles(),
-        )
-    def deploy(self) -> None:
-        """Deploy the interactive viewer as a web application."""
-        with self.viewer._deploy_app():
-            # Create components
-            self._create_components()
-            # Open browser
-            webbrowser.open(f"http://{self.config.host}:{self.config.port}")
-            # Start Flask app
-            self.app.run(
-                host=self.config.host,
-                port=self.config.port,
-                debug=False,  # Debug mode doesn't work well with matplotlib
-                use_reloader=False,  # Prevent double startup
-            )
+            result[name] = self._parse_parameter_value(name, value)
+        return result
+    def _parse_parameter_value(self, name: str, value: Any) -> Any:
+        """
+        Parse a parameter value based on its type.
+        Parameters
+        ----------
+        name : str
+            Parameter name
+        value : Any
+            Raw value
+        Returns
+        -------
+        Any
+            Parsed value
+        """
+        param = self.viewer.parameters[name]
+        if isinstance(param, TextParameter):
+            return str(value)
+        elif isinstance(param, BooleanParameter):
+            return value.lower() == "true" if isinstance(value, str) else bool(value)
+        elif isinstance(param, (IntegerParameter, UnboundedIntegerParameter)):
+            return int(value)
+        elif isinstance(param, (FloatParameter, UnboundedFloatParameter)):
+            return float(value)
+        elif isinstance(param, (IntegerRangeParameter, FloatRangeParameter)):
+            # Parse JSON array for range parameters
+            if isinstance(value, str):
+                try:
+                    return json.loads(value)
+                except json.JSONDecodeError:
+                    raise ValueError(f"Invalid range format: {value}")
+            return value
+        elif isinstance(param, MultipleSelectionParameter):
+            # Parse JSON array for multiple selection
+            if isinstance(value, str):
+                try:
+                    return json.loads(value)
+                except json.JSONDecodeError:
+                    return [value] if value else []
+            return value
+        elif isinstance(param, SelectionParameter):
+            # For SelectionParameter, we need to handle various type conversion scenarios
+            # First check if the value is already in options (exact match)
+            if value in param.options:
+                return value
+            # Handle string conversion if value is a string but options might be numeric
+            if isinstance(value, str):
+                # Try to convert to integer if it looks like an integer
+                if value.isdigit():
+                    int_value = int(value)
+                    if int_value in param.options:
+                        return int_value
+                # Try to convert to float if it has a decimal point
+                try:
+                    float_value = float(value)
+                    # Check for direct float match
+                    if float_value in param.options:
+                        return float_value
+                    # Check for float equality with integer or other float options
+                    for option in param.options:
+                        if (
+                            isinstance(option, (int, float))
+                            and abs(float_value - float(option)) < 1e-10
+                        ):
+                            return option
+                except ValueError:
+                    pass
+            # Handle numeric conversion - when value is numeric but needs type matching
+            if isinstance(value, (int, float)):
+                for option in param.options:
+                    # Convert both to float for comparison to handle int/float mismatches
+                    if (
+                        isinstance(option, (int, float))
+                        and abs(float(value) - float(option)) < 1e-10
+                    ):
+                        return option
+                    # Also try string conversion as a fallback
+                    if isinstance(option, str):
+                        try:
+                            if abs(float(value) - float(option)) < 1e-10:
+                                return option
+                        except ValueError:
+                            pass
+            # If we couldn't find a match, return the original value (will likely cause an error)
+            return value
+        else:
+            return value
+    def run(self, host: str = "127.0.0.1", port: Optional[int] = None, **kwargs):
+        """
+        Run the Flask application server.
+        Parameters
+        ----------
+        host : str, optional
+            Host to run the server on
+        port : int, optional
+            Port to run the server on. If None, an available port will be automatically found.
+        **kwargs
+            Additional arguments to pass to app.run()
+        """
+        # Find an available port if none is specified
+        if port is None:
+            port = _find_available_port()
+        run_simple(host, port, self.app, use_reloader=self.debug, **kwargs)
+def _find_available_port(start_port=5000, max_attempts=100):
+    """
+    Find an available port starting from start_port.
+    Parameters
+    ----------
+    start_port : int, optional
+        Port to start searching from
+    max_attempts : int, optional
+        Maximum number of ports to try
+    Returns
+    -------
+    int
+        An available port number
+    Raises
+    ------
+    RuntimeError
+        If no available port is found after max_attempts
+    """
+    for port in range(start_port, start_port + max_attempts):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(("127.0.0.1", port))
+                return port
+            except OSError:
+                continue
+    raise RuntimeError(
+        f"Could not find an available port after {max_attempts} attempts starting from {start_port}"
+    )
+@contextmanager
+def _plot_context():
+    """Context manager for creating matplotlib plots."""
+    try:
+        fig = plt.figure()
+        yield fig
+    finally:
+        plt.close(fig)
+def deploy_flask(
+    viewer: Viewer,
+    host: str = "127.0.0.1",
+    port: Optional[int] = None,
+    controls_position: str = "left",
+    figure_width: float = 8.0,
+    figure_height: float = 6.0,
+    controls_width_percent: int = 30,
+    debug: bool = False,
+    open_browser: bool = True,
+    **kwargs,
+):
+    """
+    Deploy a Viewer as a Flask web application.
+    Parameters
+    ----------
+    viewer : Viewer
+        The viewer to deploy
+    host : str, optional
+        Host to run the server on
+    port : int, optional
+        Port to run the server on. If None, an available port will be automatically found.
+    controls_position : str, optional
+        Position of the controls ('left', 'top', 'right', 'bottom')
+    figure_width : float, optional
+        Width of the figure in inches
+    figure_height : float, optional
+        Height of the figure in inches
+    controls_width_percent : int, optional
+        Width of the controls as a percentage of the total width
+    debug : bool, optional
+        Whether to enable debug mode
+    open_browser : bool, optional
+        Whether to open the browser automatically
+    **kwargs
+        Additional arguments to pass to app.run()
+    Returns
+    -------
+    FlaskDeployer
+        The deployer instance
+    """
+    deployer = FlaskDeployer(
+        viewer,
+        controls_position=controls_position,
+        figure_width=figure_width,
+        figure_height=figure_height,
+        controls_width_percent=controls_width_percent,
+        debug=debug,
+    )
+    # Find an available port if none is specified
+    if port is None:
+        port = _find_available_port()
+    url = f"http://{host}:{port}"
+    print(f"Interactive plot server running on {url}")
+    if open_browser:
+        # Open browser in a separate thread after a small delay
+        # to ensure the server has started
+        def open_browser_tab():
+            time.sleep(1.0)  # Short delay to allow server to start
+            webbrowser.open(url)
+        threading.Thread(target=open_browser_tab).start()
+    # This is included as an argument in some deployers but will break the Flask deployer
+    kwargs.pop("continuous", None)
+    deployer.run(host=host, port=port, **kwargs)
+    return deployer

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

syd 0.1.6py3-none-any.whl → 0.2.0py3-none-any.whl