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

syd/plotly_deployment/deployer.py

@@ -1,376 +0,0 @@
-from typing import Any, Dict, List, Optional, Literal
-import uuid
-import warnings
-from dataclasses import dataclass
-from functools import wraps
-from time import time
-from contextlib import contextmanager
-import socket
-
-from dash import Dash, html, Input, Output, callback, dcc, ALL, callback_context
-import plotly.graph_objects as go
-from plotly.tools import mpl_to_plotly
-import matplotlib as mpl
-from matplotlib import pyplot as plt
-from flask import Flask
-
-
-from ..parameters import ButtonAction, ParameterUpdateWarning
-from ..viewer import Viewer
-from .components import BaseComponent, create_component
-
-
-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'
-    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 in ["left", "right"]
-
-
-@contextmanager
-def _plot_context():
-    """Context manager to temporarily switch matplotlib backend."""
-    original_backend = mpl.get_backend()
-    plt.switch_backend("Agg")  # Switch to non-interactive backend
-    try:
-        yield
-    finally:
-        plt.switch_backend(original_backend)
-
-
-class PlotlyDeployer:
-    """
-    A deployment system for Viewer using Plotly/Dash.
-    Built around the parameter component system for clean separation of concerns.
-    """
-
-    def __init__(
-        self,
-        viewer: Viewer,
-        controls_position: str = "left",
-        controls_width_percent: int = 30,
-        component_width: str = "300px",
-        component_margin: str = "10px",
-        label_width: str = "150px",
-        continuous: bool = False,
-        suppress_warnings: bool = False,
-        title: str = "Syd Plotly App",
-        server: Optional[Flask] = None,
-    ):
-        """
-        Initialize the Plotly deployer.
-
-        Args:
-            viewer: The viewer instance to deploy
-            controls_position: Position of controls ('left', 'top', 'right', 'bottom')
-            controls_width_percent: Width of controls as percentage when horizontal
-            component_width: Default width for components
-            component_margin: Default margin for components
-            label_width: Default width for labels
-            continuous: Whether to update continuously during user interaction
-            suppress_warnings: Whether to suppress parameter update warnings
-            title: Title of the Dash application
-            server: Optional Flask server to use
-        """
-        self.viewer = viewer
-        self.config = LayoutConfig(
-            controls_position=controls_position,
-            controls_width_percent=controls_width_percent,
-        )
-        self.continuous = continuous
-        self.suppress_warnings = suppress_warnings
-
-        # Initialize Dash app
-        self.app = Dash(__name__, server=server or True, title=title)
-
-        # Component styling
-        self._component_width = component_width
-        self._component_margin = component_margin
-        self._label_width = label_width
-
-        # Initialize containers
-        self._components: Dict[str, BaseComponent] = {}
-        self._layout_ready = False
-        self._callback_registered = False
-        self._updating = False  # Flag to prevent circular updates
-
-    def _create_parameter_components(self) -> None:
-        """Create component instances for all parameters."""
-        for name, param in self.viewer.parameters.items():
-            component_id = f"{name}-{str(uuid.uuid4())[:8]}"
-            component = create_component(
-                param,
-                component_id,
-                width=self._component_width,
-                margin=self._component_margin,
-                label_width=self._label_width,
-            )
-            self._components[name] = component
-
-    @debounce(0.2)
-    def _handle_parameter_update(self, name: str, value: Any) -> None:
-        """Handle updates to parameter values."""
-        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
-
-        try:
-            self._updating = True
-
-            # Optionally suppress warnings during parameter updates
-            with warnings.catch_warnings():
-                if self.suppress_warnings:
-                    warnings.filterwarnings("ignore", category=ParameterUpdateWarning)
-
-                component = self._components[name]
-                if component._is_action:
-                    parameter = self.viewer.parameters[name]
-                    parameter.callback(self.viewer.state)
-                else:
-                    self.viewer.set_parameter_value(name, value)
-
-                # Update any components that changed due to dependencies
-                self._sync_components_with_state(exclude=name)
-
-        finally:
-            self._updating = False
-
-    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 create_layout(self) -> html.Div:
-        """Create the layout for the Dash application."""
-        # Create parameter controls section
-        param_components = [comp.component for comp in self._components.values()]
-        controls = html.Div(
-            [html.H3("Parameters", style={"marginBottom": "10px"})] + param_components,
-            style={
-                "width": (
-                    f"{self.config.controls_width_percent}%"
-                    if self.config.is_horizontal
-                    else "100%"
-                ),
-                "padding": "20px",
-                "borderRight": (
-                    "1px solid #e5e7eb"
-                    if self.config.controls_position == "left"
-                    else None
-                ),
-                "borderLeft": (
-                    "1px solid #e5e7eb"
-                    if self.config.controls_position == "right"
-                    else None
-                ),
-            },
-        )
-
-        # Create plot container
-        plot_container = html.Div(
-            id="plot-container",
-            style={
-                "width": (
-                    f"{100 - self.config.controls_width_percent}%"
-                    if self.config.is_horizontal
-                    else "100%"
-                ),
-                "padding": "20px",
-            },
-        )
-
-        # Add hidden div for state synchronization
-        state_sync = html.Div(
-            id={"type": "state_sync", "id": "sync"}, style={"display": "none"}
-        )
-
-        # Create final layout based on configuration
-        if self.config.controls_position == "left":
-            container = html.Div(
-                [controls, plot_container, state_sync], style={"display": "flex"}
-            )
-        elif self.config.controls_position == "right":
-            container = html.Div(
-                [plot_container, controls, state_sync], style={"display": "flex"}
-            )
-        elif self.config.controls_position == "top":
-            container = html.Div([controls, plot_container, state_sync])
-        else:  # bottom
-            container = html.Div([plot_container, controls, state_sync])
-
-        return html.Div(
-            container,
-            style={
-                "maxWidth": "1200px",
-                "margin": "auto",
-                "fontFamily": "sans-serif",
-            },
-        )
-
-    def setup_callbacks(self) -> None:
-        """Set up callbacks for all components."""
-        if self._callback_registered:
-            return
-
-        # Create callback for each parameter
-        for name, component in self._components.items():
-            parameter = self.viewer.parameters[name]
-
-            if not isinstance(parameter, ButtonAction):
-
-                @callback(
-                    Output(component.id, "value"),
-                    [
-                        Input(component.id, "value"),
-                        Input({"type": "state_sync", "id": ALL}, "data"),
-                    ],
-                    prevent_initial_call=True,
-                )
-                def update_parameter(value: Any, sync_data: List[Dict], n=name) -> Any:
-                    # If this is a state sync update, get the new value from viewer
-                    triggered = [p["prop_id"] for p in callback_context.triggered]
-                    if any(p.startswith("{") for p in triggered):
-                        return self.viewer.parameters[n].value
-
-                    # Otherwise handle parameter update normally
-                    self._handle_parameter_update(n, value)
-                    return value
-
-            else:
-
-                @callback(
-                    Output(component.id, "n_clicks"),
-                    Input(component.id, "n_clicks"),
-                    prevent_initial_call=True,
-                )
-                def handle_click(n_clicks: int, n=name) -> int:
-                    if n_clicks is not None and n_clicks > 0:
-                        self._handle_parameter_update(n, None)
-                    return 0  # Reset clicks
-
-        # Create callback for plot updates
-        @callback(
-            [
-                Output("plot-container", "children"),
-                Output({"type": "state_sync", "id": "sync"}, "data"),
-            ],
-            [Input(comp.id, "value") for comp in self._components.values()],
-        )
-        def update_plot(*values):
-            with _plot_context():
-                fig = self.viewer.plot(self.viewer.state)
-
-                # If it's already a Plotly figure, use it directly
-                if isinstance(fig, (go.Figure, dict)):
-                    plotly_fig = fig
-                else:
-                    # Convert matplotlib figure to plotly
-                    plotly_fig = mpl_to_plotly(fig)
-                    plt.close(fig)  # Clean up the matplotlib figure
-
-            return dcc.Graph(figure=plotly_fig), {"timestamp": time()}
-
-        self._callback_registered = True
-
-    def find_available_port(self, start_port=8050, max_attempts=100):
-        """Find an available port starting from start_port"""
-        for port in range(start_port, start_port + max_attempts):
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                try:
-                    s.bind(("", port))
-                    return port
-                except socket.error:
-                    continue
-        raise RuntimeError(
-            f"No available ports found between {start_port} and {start_port + max_attempts}"
-        )
-
-    def deploy(
-        self,
-        mode: Literal["notebook", "server"] = "notebook",
-        host: str = "127.0.0.1",
-        port: int = 8050,
-        debug: bool = False,
-        max_port_attempts: int = 100,
-    ) -> None:
-        """
-        Deploy the Dash application.
-
-        Args:
-            mode: How to deploy the app - 'notebook' for Jupyter integration or 'server' for standalone web server
-            host: Host address to run the server on (only used in server mode)
-            port: Starting port to try running the server on (only used in server mode)
-            debug: Whether to run in debug mode
-            max_port_attempts: Maximum number of ports to try if initial port is taken
-        """
-        with self.viewer._deploy_app():
-            # Create components
-            self._create_parameter_components()
-
-            # Set up layout
-            if not self._layout_ready:
-                self.app.layout = self.create_layout()
-                self._layout_ready = True
-
-            # Set up callbacks
-            if not self._callback_registered:
-                self.setup_callbacks()
-
-            # Find available port if in server mode
-            if mode == "server":
-                port = self.find_available_port(
-                    start_port=port, max_attempts=max_port_attempts
-                )
-
-            # Handle warnings based on debug mode
-            with warnings.catch_warnings():
-                if not debug:
-                    warnings.filterwarnings("ignore", category=UserWarning)
-
-                if mode == "notebook":
-                    # Configure JupyterDash for notebook display
-                    self.app.run_server(mode="inline", port=port, debug=debug)
-                else:  # server mode
-                    # Run as a standalone server
-                    self.app.run(jupyter_mode="tab", host=host, port=port, debug=debug)

syd-0.1.7.dist-info/METADATA

@@ -1,120 +0,0 @@
-Metadata-Version: 2.4
-Name: syd
-Version: 0.1.7
-Summary: A Python package for making GUIs for data science easy.
-Project-URL: Homepage, https://github.com/landoskape/syd
-Author-email: Andrew Landau <andrew+tyler+landau+getridofthisanddtheplusses@gmail.com>
-License-Expression: GPL-3.0-or-later
-License-File: LICENSE
-Keywords: data-science,gui,interactive,jupyter,machine-learning,notebook,python
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.9
-Requires-Dist: dash
-Requires-Dist: ipympl
-Requires-Dist: ipywidgets
-Requires-Dist: matplotlib
-Requires-Dist: plotly
-Provides-Extra: test
-Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
-Requires-Dist: pytest>=7.0.0; extra == 'test'
-Description-Content-Type: text/markdown
-
-# syd
-
-[![PyPI version](https://badge.fury.io/py/syd.svg)](https://badge.fury.io/py/syd)
-[![Tests](https://github.com/landoskape/syd/actions/workflows/tests.yml/badge.svg)](https://github.com/landoskape/syd/actions/workflows/tests.yml)
-[![Documentation Status](https://readthedocs.org/projects/shareyourdata/badge/?version=stable)](https://shareyourdata.readthedocs.io/en/stable/?badge=stable)
-[![codecov](https://codecov.io/gh/landoskape/syd/branch/main/graph/badge.svg)](https://codecov.io/gh/landoskape/syd)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-
-
-A package to help you share your data!
-
-Have you ever wanted to look through all your data really quickly interactively? Of course you have. Mo data mo problems, but only if you don't know what to do with it. And that starts with looking at your data. And that's why syd stands for show your data! 
-
-Syd is a system for creating a data viewing GUI that you can view on a web-browser (feature coming soon, right now only in jupyter notebooks). And guess what? Since it opens on a web browser, you can even open it on any other computer on your local network! For example, your PI's computer. Gone are the days of single random examples that they make infinitely stubborn conclusions about. Now, you can look at all the examples, quickly and easily, on their computer. And that's why syd stands for share your data!
-
-Okay, so what is it? Syd is an automated system to convert some basic python plotting code into an interactive GUI. This is great, because it means you only have to think about what you want to plot and which parameters you want to be interactive. Syd handles all the behind-the-scenes boilerplate code required to make an interface. You know what that means? It means you get to focus on _thinking_ about your data, rather than spending time writing code to look at it. And that's why syd stands for Science, Yes! Dayummmm!
-
-## Installation
-It's easy, just use pip install. The dependencies are light so it should work in most environments.
-```bash
-pip install syd
-```
-
-## Quick Start
-Right now the only way to use it is in a jupyter notebook. More deployment options coming soon!
-This is an example of a sine wave viewer which is about as simple as it gets. 
-```python
-# In a notebook! 
-import matplotlib.pyplot as plt
-import numpy as np
-from syd import make_viewer
-def plot(viewer, state):
-    fig, ax = plt.subplots()
-    x = np.linspace(0, 10, 1000)
-    y = state['amplitude'] * np.sin(state['frequency'] * x)
-    ax.plot(x, y)
-    return fig
-        
-viewer = make_viewer()
-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.deploy(continuous=True)
-```
-
-We have several examples of more complex viewers in the [examples](examples) folder. A good one
-to start with is the [first example](examples/first_example.ipynb) because this has detailed 
-explanations of how to use the core elements of SYD. To see what the exact same viewer looks like
-when written as a class, see the [subclass example](examples/subclass_example.ipynb). This format
-is pretty useful when you want complex functionality - for example if you want to add extra
-supporting methods for processing data and updating parameters that require more complex logic.
-
-## Documentation
-
-Full documentation is available at [shareyourdata.readthedocs.io](https://shareyourdata.readthedocs.io/).
-
-## License
-
-This project is licensed under the GNU General Public License v3.0 - see the [LICENSE](LICENSE) file for details.
-
-## Contributing
-
-Contributions are welcome! Here's how you can help:
-
-1. Fork the repository
-2. Create a new branch (`git checkout -b feature/amazing-feature`)
-3. Make your changes
-4. Run the tests (`pytest`)
-5. Commit your changes (`git commit -m 'Add amazing feature'`)
-6. Push to the branch (`git push origin feature/amazing-feature`)
-7. Open a Pull Request online
-
-Please make sure to update tests as appropriate and adhere to the existing coding style (black, line-length=88, other style guidelines not capture by black, generally following pep8 guidelines).
-
-
-## To-Do List
-- Notebook deployment debouncer: 
-  - Probably make this dependent on whether the user is in %matplotlib widget mode or not
-  - Also probably make it dependent on whether the deployer is in continuous mode or not
-  - Potentially make the wait_time dynamic depending on how fast the plot method is and how
-  - frequently the no comm messages show up... (if we can catch them)
-- Consider the class method "of this class" function permissions.... (and write tests...)
-- Think about whether there's alternatives to creating new figures each time...
-- Consider adding a step to the integer parameter...
-- Idea!
-  - We could make fig=?, ax=? arguments optional for the plot function and add a
-    "recycle_figure: bool = False" flag be part of the deploy API. This way, an
-    advanced user that wants snappy responsivity or complex figure management can
-    do so, but the default is for the user to generate a new figure object each time.
-- I've updated some rules for parameters -- need to make tests for empty options on selection / multiple selections

syd-0.1.7.dist-info/RECORD

@@ -1,22 +0,0 @@
-syd/__init__.py,sha256=jAUVYiFfmoEyXcMMeSEB44U8f9s2PQDPFvnGt9P2GmE,250
-syd/parameters.py,sha256=5VcqTPHP-Jj4PjQxQ1NCnkysHPwfxjdsaQbtvDf76bU,44348
-syd/viewer.py,sha256=ClpPhseWIP1L0cVObkZXfoa9oD48dOUMTvDz2ovyG9c,51006
-syd/flask_deployment/__init__.py,sha256=AeCaOInJYkowwK-1Eo2TW7M5Smzar4j9C0_5gxsrl_w,36
-syd/flask_deployment/components.py,sha256=J8LFQzHCq0U_GeYmo3uf8WuGq09tEw9beVRO5UPELnw,20335
-syd/flask_deployment/deployer.py,sha256=YMbHDf7Ge8B7wJEmCU5rKHtHNN8c7RkzEYDA4FRY4w4,10131
-syd/flask_deployment/testing_principles.md,sha256=bIR6RDvAxX1uB8wauIT62FX1jMYSjNPlXWsZ4rUE1Gw,10178
-syd/flask_deployment/static/css/viewer.css,sha256=b6ZhAK85bPRqTFzB77IaVOAbgDRDusDE1u6wbve8OaY,1246
-syd/flask_deployment/static/js/viewer.js,sha256=AA8IyEvRjk_RLTLDduku8eT-ztZAdBw5gGaCt2saZSk,5995
-syd/flask_deployment/templates/base.html,sha256=L1lHEjUBSCqG1B6KnbApUshVopr7mZLRwzA3jRcKtMQ,935
-syd/flask_deployment/templates/viewer.html,sha256=xFbdO8fTQ4MgqyEGFJLM4-b1UAlijLPxIr7aLhDD7VA,1953
-syd/notebook_deployment/__init__.py,sha256=0DZ-psAZBt6dx_a5Dc8wLK-rKTn8yDvTmQOcL6Le3l8,39
-syd/notebook_deployment/_ipympl_deployer.py,sha256=CoumoX5U63YX4luhul5eO8JufJTgHvZgExEriAlxhW0,8972
-syd/notebook_deployment/deployer.py,sha256=rPB-FKmL5tDUcG1mC2MCVlGFcDSJK_sBb8knndWVIcA,11275
-syd/notebook_deployment/widgets.py,sha256=4MfFKRAT0dUhNeia-Tpzp5N1ql0QioOVJ2ySOqUBkl0,19336
-syd/plotly_deployment/__init__.py,sha256=y9j4WKQOERSaxCVoaFUrpudwQ8DEGPfqrCcNqoc7e2U,37
-syd/plotly_deployment/components.py,sha256=HMPyxdIdsok-VolOWVoWeFya1kzMLvIyQ6ufa-FlKbo,16861
-syd/plotly_deployment/deployer.py,sha256=L2yvvkmbWYKNQt_x5mVg552L7a-TeN0ZcW8luRm2I4o,13735
-syd-0.1.7.dist-info/METADATA,sha256=tvGs0W0aIe3T0ut0V8EnPygIscdpev-4l4sjaK4-GWE,6489
-syd-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-syd-0.1.7.dist-info/licenses/LICENSE,sha256=YF6QR6Vjxcg5b_sYIyqkME7FZYau5TfEUGTG-0JeRK0,35129
-syd-0.1.7.dist-info/RECORD,,