syd 1.0.0__tar.gz → 1.0.2__tar.gz

{syd-1.0.0 → syd-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syd
-Version: 1.0.0
+Version: 1.0.2
 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>
@@ -37,13 +37,17 @@ Description-Content-Type: text/markdown
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 
+<div>
+    <img src="./docs/assets/syd-logo-white.png" alt="Syd" width="350" align="right"/>
+</div>
+
 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's why Syd stands for show your data! 
 
 Syd is a system for creating a data viewing GUI that you can view in a jupyter notebook or in a web browser. And guess what? Since it can open in 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 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 action required to make an interface. And do you know what that means? It means you get to spend your time _thinking_ about your data, rather than writing code to look at it. And that's why Syd stands for Science, Yes! Dayummmm!
+Okay, so what is it? Syd is an automated system to convert some basic python plotting code into an interactive GUI. This 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 action required to make an interface. And guess what? That means you get to spend your time _**thinking**_ about your data, rather than 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.
@@ -56,27 +60,31 @@ The full documentation is available at [shareyourdata.readthedocs.io](https://sh
 
 ## Quick Start
 This is an example of a sine wave viewer which is about as simple as it gets. You can choose which env to use - if you use ``env="notebook"`` then the GUI will deploy as the output of a jupyter cell (this only works in jupyter!). If you use ``env="browser"`` then the GUI will open a page in your default web browser and you can interact with the data there (works in jupyter notebooks and also from python scripts!).
+
 ```python
-import matplotlib.pyplot as plt
 import numpy as np
+import matplotlib.pyplot as plt
 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)
+def plot(state):
+    # Here's a simple plot function that plots a sine wave
+    fig = plt.figure()
+    t = np.linspace(0, 2 * np.pi, 1000)
+    ax = plt.gca()
+    ax.plot(t, state["amplitude"] * np.sin(state["frequency"] * t), color=state["color"])
     return fig
-        
-viewer = make_viewer()
-viewer.set_plot(plot)
-viewer.add_float('amplitude', value=1.0, min=0, max=2)
-viewer.add_float('frequency', value=1.0, min=0.1, max=5)
+
+viewer = make_viewer(plot)
+viewer.add_float("amplitude", value=1.0, min=0.1, max=2.0)
+viewer.add_float("frequency", value=1.0, min=0.1, max=5.0)
+viewer.add_selection("color", value="red", options=["red", "blue", "green", "black"])
 
 # env = "browser" # for viewing in a web browser
 env = "notebook" # for viewing within a jupyter notebook
-viewer.deploy(env=env)
+viewer.show()
 ```
 
+![Quick Start Viewer](./docs/assets/viewer_screenshots/readme_example_gif.gif)
+
 ### More Examples
 We have several examples of more complex viewers with detailed explanations in the comments. Here are the links and descriptions to each of them:
 
@@ -90,7 +98,7 @@ We have several examples of more complex viewers with detailed explanations in t
 
 
 ### Data loading
-Thinking about how to get data into a Syd viewer can be non-intuitive. For some examples that showcase different ways to get your data into a Syd viewer, check out the [data loading example](examples/3-data_loading.ipynb). Or, if you just want a quick example, check this out:
+Thinking about how to get data into a Syd viewer can be non-intuitive. For some examples that showcase different ways to get your data into a Syd viewer, check out the [data loading example](examples/3-data_loading.ipynb). Or, if you just want a quick and fast example, check this one out:
 ```python
 import numpy as np
 from matplotlib import pyplot as plt
@@ -111,15 +119,15 @@ def plot(state):
 # Since plot "knows" about the data variable, all you need to do is pass the plot
 # function to the syd viewer and it'll be able to access the data once deployed!
 viewer = make_viewer(plot)
-viewer.deploy(env="browser")
+viewer.show()
 ```
 
 ### Handling Hierarchical Callbacks
-Syd dramatically reduces the amount of work you need to do to build a GUI for viewing your data. However, it can still be a bit complicated to think about callbacks. Below is a quick demonstration, to try it yourself, check out the full example [here](examples/4-hierarchical_callbacks.ipynb).
+Syd dramatically reduces the amount of work you need to do to build a GUI for viewing your data. However, it can still be a bit complicated to think about callbacks. Below is a quick demonstration. To try it yourself, check out the full example [here](examples/4-hierarchical_callbacks.ipynb) or open it in colab [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/landoskape/syd/blob/main/examples/4-hierarchical_callbacks.ipynb).
 
-For example, suppose your dataset is composed of electrophysiology recordings from 3 mice, where each mouse has a different number of sesssions, and each session has a different number of neurons. You want to build a viewer to choose the mouse, then choose the session, and then view a particular neuron from within that session. But the viewer will break if you try to index to session 5 for mouse 2 but mouse 2 only has 4 sessions!
+For example, suppose your dataset is composed of electrophysiology recordings from 3 mice, where each mouse has a different number of sesssions, and each session has a different number of neurons. You want to build a viewer to view a particular neuron from a particular session from a particular mouse. But the viewer will break if you try to index to session 5 for mouse 2 when mouse 2 has less than 5 sessions!
 
-This is where hierarchical callbacks come in. There's a straightforward pattern to handling this kind of situation that you can follow. You can write a callback for each **level** of the hierarchy. Then, each callback can call the next callback in the hierarchy. It looks like this: 
+This is where hierarchical callbacks come in. There's a straightforward pattern to handling this kind of situation that you can follow. You can write a callback for each **level** of the hierarchy. Then, each callback can **update** the state and call the next callback in the hierarchy once it's finished. It looks like this: 
 ```python
 import numpy as np
 from syd import Viewer # Much easier to build a Viewer class for hierarchical callbacks
@@ -130,19 +138,22 @@ class MouseViewer(Viewer):
 
         self.add_selection("mouse", options=list(mice_names))
 
-        # We don't know how many sessions or neurons to pick from yet!
+        # We don't know how many sessions or neurons to pick from yet,
+        # so just set the max to 1 for now.
         self.add_integer("session", min=0, max=1)
         self.add_integer("neuron", min=0, max=1)
         
-        # Any time the mouse changes, update the sessions to pick from
+        # Any time the mouse changes, update the sessions to pick from!
         self.on_change("mouse", self.update_mouse)
 
-        # Any time the session changes, update the neurons to pick from
+        # Any time the session changes, update the neurons to pick from!
         self.on_change("session", self.update_session)
 
         # Since we built callbacks for setting the range of the session
-        # and neuron parameters, we can use them here!
-        # To get the state, we can use self.state, which is the current
+        # and neuron parameters, we can use them here so the viewer is
+        # fully ready and up to date.
+
+        # To get the state, use self.state, which is the current
         # state of the viewer (in the init function, it'll just be the
         # default value for each parameter you've added already).
         self.update_mouse(self.state)
@@ -155,9 +166,13 @@ class MouseViewer(Viewer):
         self.update_integer("session", max=num_sessions - 1)
 
         # Now we need to update the neurons to choose from ....
-        # But! Updating the session parameter might trigger a change to the
-        # session value. So, instead of using the state dictionary that was
-        # passed into the function, we can get the ~NEW~ state dictionary like this:
+
+        # But! Updating the session parameter's max value might trigger a change
+        # to the current session value. This ~won't be reflected~ in the state 
+        # dictionary that was passed to this function.
+        
+        # So, we need to load the ~NEW~ state dictionary, which is always 
+        # accessible as self.state (or viewer.state if you're not using a class).
         new_state = self.state
 
         # Then perform the session update callback!
@@ -178,7 +193,7 @@ class MouseViewer(Viewer):
 
 # Now we can create a viewer and deploy it
 viewer = MouseViewer(["Mouse 1", "Mouse 2", "Mouse 3"])
-viewer.deploy(env="browser")
+viewer.show()
 ```
 
 ## License
@@ -197,8 +212,11 @@ Contributions are welcome! Here's how you can help:
 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).
-
+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). Try to make the code coverage report improve or stay the same rather than decrease (right now the deployment system isn't covered by tests). I don't have any precommit hooks or anything so you're responsible for checking this yourself. You can process the code with black as follows:
+```bash
+pip install black
+black . # from the root directory of the repo
+```
 
 ## To-Do List
 - Layout controls
@@ -208,12 +226,6 @@ Please make sure to update tests as appropriate and adhere to the existing codin
   - [ ] Add a "freeze" button that allows the user to update state variables without updating the plot until unfreezing
   - [ ] Add a window for capturing any error messages that might be thrown by the plot function. Maybe we could have a little interface for looking at each one (up to a point) and the user could press a button to throw an error for the traceback. 
 - [ ] Consider "app_deployed" context for each deployer...
-- [ ] Consider adding a step to the integer parameters...
-- Idea for figure management:
-  - [ ] 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.
 - Export options:
   - [ ] Export lite: export the viewer as a HTML/Java package that contains an incomplete set of renderings of figures -- using a certain set of parameters.
   - [ ] Export full: export the viewer in a way that contains the data to give full functionality.

{syd-1.0.0 → syd-1.0.2}/README.md

@@ -7,13 +7,17 @@
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 
+<div>
+    <img src="./docs/assets/syd-logo-white.png" alt="Syd" width="350" align="right"/>
+</div>
+
 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's why Syd stands for show your data! 
 
 Syd is a system for creating a data viewing GUI that you can view in a jupyter notebook or in a web browser. And guess what? Since it can open in 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 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 action required to make an interface. And do you know what that means? It means you get to spend your time _thinking_ about your data, rather than writing code to look at it. And that's why Syd stands for Science, Yes! Dayummmm!
+Okay, so what is it? Syd is an automated system to convert some basic python plotting code into an interactive GUI. This 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 action required to make an interface. And guess what? That means you get to spend your time _**thinking**_ about your data, rather than 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.
@@ -26,27 +30,31 @@ The full documentation is available at [shareyourdata.readthedocs.io](https://sh
 
 ## Quick Start
 This is an example of a sine wave viewer which is about as simple as it gets. You can choose which env to use - if you use ``env="notebook"`` then the GUI will deploy as the output of a jupyter cell (this only works in jupyter!). If you use ``env="browser"`` then the GUI will open a page in your default web browser and you can interact with the data there (works in jupyter notebooks and also from python scripts!).
+
 ```python
-import matplotlib.pyplot as plt
 import numpy as np
+import matplotlib.pyplot as plt
 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)
+def plot(state):
+    # Here's a simple plot function that plots a sine wave
+    fig = plt.figure()
+    t = np.linspace(0, 2 * np.pi, 1000)
+    ax = plt.gca()
+    ax.plot(t, state["amplitude"] * np.sin(state["frequency"] * t), color=state["color"])
     return fig
-        
-viewer = make_viewer()
-viewer.set_plot(plot)
-viewer.add_float('amplitude', value=1.0, min=0, max=2)
-viewer.add_float('frequency', value=1.0, min=0.1, max=5)
+
+viewer = make_viewer(plot)
+viewer.add_float("amplitude", value=1.0, min=0.1, max=2.0)
+viewer.add_float("frequency", value=1.0, min=0.1, max=5.0)
+viewer.add_selection("color", value="red", options=["red", "blue", "green", "black"])
 
 # env = "browser" # for viewing in a web browser
 env = "notebook" # for viewing within a jupyter notebook
-viewer.deploy(env=env)
+viewer.show()
 ```
 
+![Quick Start Viewer](./docs/assets/viewer_screenshots/readme_example_gif.gif)
+
 ### More Examples
 We have several examples of more complex viewers with detailed explanations in the comments. Here are the links and descriptions to each of them:
 
@@ -60,7 +68,7 @@ We have several examples of more complex viewers with detailed explanations in t
 
 
 ### Data loading
-Thinking about how to get data into a Syd viewer can be non-intuitive. For some examples that showcase different ways to get your data into a Syd viewer, check out the [data loading example](examples/3-data_loading.ipynb). Or, if you just want a quick example, check this out:
+Thinking about how to get data into a Syd viewer can be non-intuitive. For some examples that showcase different ways to get your data into a Syd viewer, check out the [data loading example](examples/3-data_loading.ipynb). Or, if you just want a quick and fast example, check this one out:
 ```python
 import numpy as np
 from matplotlib import pyplot as plt
@@ -81,15 +89,15 @@ def plot(state):
 # Since plot "knows" about the data variable, all you need to do is pass the plot
 # function to the syd viewer and it'll be able to access the data once deployed!
 viewer = make_viewer(plot)
-viewer.deploy(env="browser")
+viewer.show()
 ```
 
 ### Handling Hierarchical Callbacks
-Syd dramatically reduces the amount of work you need to do to build a GUI for viewing your data. However, it can still be a bit complicated to think about callbacks. Below is a quick demonstration, to try it yourself, check out the full example [here](examples/4-hierarchical_callbacks.ipynb).
+Syd dramatically reduces the amount of work you need to do to build a GUI for viewing your data. However, it can still be a bit complicated to think about callbacks. Below is a quick demonstration. To try it yourself, check out the full example [here](examples/4-hierarchical_callbacks.ipynb) or open it in colab [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/landoskape/syd/blob/main/examples/4-hierarchical_callbacks.ipynb).
 
-For example, suppose your dataset is composed of electrophysiology recordings from 3 mice, where each mouse has a different number of sesssions, and each session has a different number of neurons. You want to build a viewer to choose the mouse, then choose the session, and then view a particular neuron from within that session. But the viewer will break if you try to index to session 5 for mouse 2 but mouse 2 only has 4 sessions!
+For example, suppose your dataset is composed of electrophysiology recordings from 3 mice, where each mouse has a different number of sesssions, and each session has a different number of neurons. You want to build a viewer to view a particular neuron from a particular session from a particular mouse. But the viewer will break if you try to index to session 5 for mouse 2 when mouse 2 has less than 5 sessions!
 
-This is where hierarchical callbacks come in. There's a straightforward pattern to handling this kind of situation that you can follow. You can write a callback for each **level** of the hierarchy. Then, each callback can call the next callback in the hierarchy. It looks like this: 
+This is where hierarchical callbacks come in. There's a straightforward pattern to handling this kind of situation that you can follow. You can write a callback for each **level** of the hierarchy. Then, each callback can **update** the state and call the next callback in the hierarchy once it's finished. It looks like this: 
 ```python
 import numpy as np
 from syd import Viewer # Much easier to build a Viewer class for hierarchical callbacks
@@ -100,19 +108,22 @@ class MouseViewer(Viewer):
 
         self.add_selection("mouse", options=list(mice_names))
 
-        # We don't know how many sessions or neurons to pick from yet!
+        # We don't know how many sessions or neurons to pick from yet,
+        # so just set the max to 1 for now.
         self.add_integer("session", min=0, max=1)
         self.add_integer("neuron", min=0, max=1)
         
-        # Any time the mouse changes, update the sessions to pick from
+        # Any time the mouse changes, update the sessions to pick from!
         self.on_change("mouse", self.update_mouse)
 
-        # Any time the session changes, update the neurons to pick from
+        # Any time the session changes, update the neurons to pick from!
         self.on_change("session", self.update_session)
 
         # Since we built callbacks for setting the range of the session
-        # and neuron parameters, we can use them here!
-        # To get the state, we can use self.state, which is the current
+        # and neuron parameters, we can use them here so the viewer is
+        # fully ready and up to date.
+
+        # To get the state, use self.state, which is the current
         # state of the viewer (in the init function, it'll just be the
         # default value for each parameter you've added already).
         self.update_mouse(self.state)
@@ -125,9 +136,13 @@ class MouseViewer(Viewer):
         self.update_integer("session", max=num_sessions - 1)
 
         # Now we need to update the neurons to choose from ....
-        # But! Updating the session parameter might trigger a change to the
-        # session value. So, instead of using the state dictionary that was
-        # passed into the function, we can get the ~NEW~ state dictionary like this:
+
+        # But! Updating the session parameter's max value might trigger a change
+        # to the current session value. This ~won't be reflected~ in the state 
+        # dictionary that was passed to this function.
+        
+        # So, we need to load the ~NEW~ state dictionary, which is always 
+        # accessible as self.state (or viewer.state if you're not using a class).
         new_state = self.state
 
         # Then perform the session update callback!
@@ -148,7 +163,7 @@ class MouseViewer(Viewer):
 
 # Now we can create a viewer and deploy it
 viewer = MouseViewer(["Mouse 1", "Mouse 2", "Mouse 3"])
-viewer.deploy(env="browser")
+viewer.show()
 ```
 
 ## License
@@ -167,8 +182,11 @@ Contributions are welcome! Here's how you can help:
 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).
-
+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). Try to make the code coverage report improve or stay the same rather than decrease (right now the deployment system isn't covered by tests). I don't have any precommit hooks or anything so you're responsible for checking this yourself. You can process the code with black as follows:
+```bash
+pip install black
+black . # from the root directory of the repo
+```
 
 ## To-Do List
 - Layout controls
@@ -178,12 +196,6 @@ Please make sure to update tests as appropriate and adhere to the existing codin
   - [ ] Add a "freeze" button that allows the user to update state variables without updating the plot until unfreezing
   - [ ] Add a window for capturing any error messages that might be thrown by the plot function. Maybe we could have a little interface for looking at each one (up to a point) and the user could press a button to throw an error for the traceback. 
 - [ ] Consider "app_deployed" context for each deployer...
-- [ ] Consider adding a step to the integer parameters...
-- Idea for figure management:
-  - [ ] 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.
 - Export options:
   - [ ] Export lite: export the viewer as a HTML/Java package that contains an incomplete set of renderings of figures -- using a certain set of parameters.
   - [ ] Export full: export the viewer in a way that contains the data to give full functionality.

{syd-1.0.0 → syd-1.0.2}/syd/__init__.py

@@ -1,7 +1,7 @@
 from typing import Callable, Optional
 from .viewer import Viewer
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"
 
 
 def make_viewer(plot_func: Optional[Callable] = None):

{syd-1.0.0 → syd-1.0.2}/syd/notebook_deployment/deployer.py

@@ -1,5 +1,7 @@
 from typing import Literal, Optional
 import warnings
+import threading
+from contextlib import contextmanager
 import ipywidgets as widgets
 from IPython.display import display
 import matplotlib as mpl
@@ -39,6 +41,7 @@ class NotebookDeployer:
         controls_width_percent: int = 20,
         continuous: bool = False,
         suppress_warnings: bool = True,
+        update_threshold: float = 1.0,
     ):
         self.viewer = viewer
         self.components: dict[str, BaseWidget] = {}
@@ -56,12 +59,58 @@ class NotebookDeployer:
                 "The behavior of the viewer will almost definitely not work as expected!"
             )
         self._last_figure = None
+        self._update_event = threading.Event()
+        self.update_threshold = update_threshold
+        self._slow_loading_figure = None
+        self._display_lock = threading.Lock()  # Lock for synchronizing display updates
+
+    def _show_slow_loading(self):
+        if self.backend_type == "inline":
+            if not self._update_event.wait(self.update_threshold):
+                if self._slow_loading_figure is None:
+                    fig = plt.figure()
+                    ax = fig.add_subplot(111)
+                    ax.text(
+                        0.5,
+                        0.5,
+                        "waiting for next figure...",
+                        ha="center",
+                        va="center",
+                        fontsize=12,
+                        weight="bold",
+                        color="black",
+                    )
+                    ax.axis("off")
+                    self._slow_loading_figure = fig
+                if not self._showing_new_figure:
+                    self._display_figure(self._slow_loading_figure, store_figure=False)
+                    self._showing_slow_loading_figure = True
+
+    @contextmanager
+    def _perform_update(self):
+        self._updating = True
+        self._showing_new_figure = False
+        self._showing_slow_loading_figure = False
+        self._update_event.clear()
+
+        thread = threading.Thread(target=self._show_slow_loading, daemon=True)
+        thread.start()
+
+        try:
+            yield
+        finally:
+            self._updating = False
+            self._update_event.set()
+            thread.join()
+            if self._showing_slow_loading_figure:
+                self._display_figure(self._last_figure)
+            self._update_status("Ready!")
 
     def deploy(self) -> None:
         """Deploy the viewer."""
+        self.backend_type = get_backend_type()
         self.build_components()
         self.build_layout()
-        self.backend_type = get_backend_type()
         display(self.layout)
         self.update_plot()
 
@@ -80,6 +129,10 @@ class NotebookDeployer:
 
         # Controls width slider for horizontal layouts
         self.controls = {}
+        self.controls["status"] = widgets.HTML(
+            value="<b>Syd Controls</b>",
+            layout=widgets.Layout(width="95%"),
+        )
         if self.controls_position in ["left", "right"]:
             self.controls["controls_width"] = widgets.IntSlider(
                 value=self.controls_width_percent,
@@ -90,6 +143,15 @@ class NotebookDeployer:
                 layout=widgets.Layout(width="95%"),
                 style={"description_width": "initial"},
             )
+        if self.backend_type == "inline":
+            self.controls["update_threshold"] = widgets.FloatSlider(
+                value=self.update_threshold,
+                min=0.1,
+                max=10.0,
+                description="Update Threshold",
+                layout=widgets.Layout(width="95%"),
+                style={"description_width": "initial"},
+            )
 
         # Create parameter controls section
         param_box = widgets.VBox(
@@ -102,7 +164,7 @@ class NotebookDeployer:
         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()),
+                list(self.controls.values()),
                 layout=widgets.Layout(margin="10px 0px"),
             )
 
@@ -112,6 +174,11 @@ class NotebookDeployer:
                     self._handle_container_width_change, names="value"
                 )
 
+            if "update_threshold" in self.controls:
+                self.controls["update_threshold"].observe(
+                    self._handle_update_threshold_change, names="value"
+                )
+
             widgets_elements = [param_box, layout_box]
         else:
             widgets_elements = [param_box]
@@ -154,6 +221,8 @@ class NotebookDeployer:
         else:
             self.layout = widgets.VBox([self.widgets_container, self.plot_container])
 
+        self._update_status("Ready!")
+
     def handle_component_engagement(self, name: str) -> None:
         """Handle engagement with an interactive component."""
         if self._updating:
@@ -164,9 +233,8 @@ class NotebookDeployer:
             )
             return
 
-        try:
-            self._updating = True
-
+        with self._perform_update():
+            self._update_status(f"Updating {name}")
             # Optionally suppress warnings during parameter updates
             with warnings.catch_warnings():
                 if self.suppress_warnings:
@@ -188,9 +256,6 @@ class NotebookDeployer:
                 # Update the plot
                 self.update_plot()
 
-        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():
@@ -211,25 +276,32 @@ class NotebookDeployer:
         # Update components if plot function updated a parameter
         self.sync_components_with_state()
 
-        # Close the last figure if it exists to keep matplotlib clean
-        if self._last_figure is not None:
-            plt.close(self._last_figure)
+        self._display_figure(figure)
+
+        self._showing_new_figure = True
 
-        self.plot_output.clear_output(wait=True)
-        with self.plot_output:
-            if self.backend_type == "inline":
-                display(figure)
+    def _display_figure(self, figure: plt.Figure, store_figure: bool = True) -> None:
+        with self._display_lock:
+            # Close the last figure if it exists to keep matplotlib clean
+            if self._last_figure is not None:
+                plt.close(self._last_figure)
 
-                # Also required to make sure a second figure window isn't opened
-                plt.close(figure)
+            self.plot_output.clear_output(wait=True)
+            with self.plot_output:
+                if self.backend_type == "inline":
+                    display(figure)
 
-            elif self.backend_type == "widget":
-                display(figure.canvas)
+                    # Also required to make sure a second figure window isn't opened
+                    plt.close(figure)
 
-            else:
-                raise ValueError(f"Unsupported backend type: {self.backend_type}")
+                elif self.backend_type == "widget":
+                    display(figure.canvas)
 
-        self._last_figure = figure
+                else:
+                    raise ValueError(f"Unsupported backend type: {self.backend_type}")
+
+            if store_figure:
+                self._last_figure = figure
 
     def _handle_container_width_change(self, _) -> None:
         """Handle changes to container width proportions."""
@@ -239,3 +311,15 @@ class NotebookDeployer:
         # Update container widths
         self.widgets_container.layout.width = f"{width_percent}%"
         self.plot_container.layout.width = f"{100 - width_percent}%"
+
+    def _handle_update_threshold_change(self, _) -> None:
+        """Handle changes to update threshold."""
+        self.update_threshold = self.controls["update_threshold"].value
+
+    def _update_status(self, status: str) -> None:
+        """Update the status text."""
+        value = "<b>Syd Controls</b>  "
+        value += "<span style='background-color: #e0e0e0; color: #000; padding: 2px 6px; border-radius: 4px; font-size: 90%;'>"
+        value += f"Status: {status}"
+        value += "</span>"
+        self.controls["status"].value = value

{syd-1.0.0 → syd-1.0.2}/syd/viewer.py

@@ -1,4 +1,4 @@
-from typing import List, Any, Callable, Dict, Tuple, Union, Optional
+from typing import List, Any, Callable, Dict, Tuple, Union, Optional, Literal
 from functools import wraps, partial
 import inspect
 from contextlib import contextmanager
@@ -212,6 +212,54 @@ class Viewer:
         """Set the plot method for the viewer"""
         self.plot = self._prepare_function(func, context="Setting plot:")
 
+    def show(
+        self,
+        controls_position: Literal["left", "top", "right", "bottom"] = "left",
+        controls_width_percent: int = 20,
+        continuous: bool = False,
+        suppress_warnings: bool = True,
+        update_threshold: float = 1.0,
+    ):
+        """Show the viewer in a notebook
+
+        Same as deploy(env="notebook") except it doesn't return the viewer object.
+        """
+        _ = self.deploy(
+            env="notebook",
+            controls_position=controls_position,
+            controls_width_percent=controls_width_percent,
+            continuous=continuous,
+            suppress_warnings=suppress_warnings,
+            update_threshold=update_threshold,
+        )
+
+    def share(
+        self,
+        controls_position: str = "left",
+        fig_dpi: int = 300,
+        controls_width_percent: int = 20,
+        suppress_warnings: bool = True,
+        debug: bool = False,
+        host: str = "127.0.0.1",
+        port: Optional[int] = None,
+        open_browser: bool = True,
+    ):
+        """Share the viewer on a web browser using Flask
+
+        Same as deploy(env="browser") except it doesn't return the viewer object.
+        """
+        _ = self.deploy(
+            env="browser",
+            controls_position=controls_position,
+            fig_dpi=fig_dpi,
+            controls_width_percent=controls_width_percent,
+            suppress_warnings=suppress_warnings,
+            debug=debug,
+            host=host,
+            port=port,
+            open_browser=open_browser,
+        )
+
     def deploy(self, env: str = "notebook", **kwargs):
         """Deploy the app in a notebook or standalone environment"""
         env = env.lower()
@@ -223,7 +271,7 @@ class Viewer:
             deployer.deploy()
             return self
 
-        elif env == "browser" or env == "flask":
+        elif env == "browser":
             # On demand import because the deployers need to import the viewer
             from .flask_deployment.deployer import FlaskDeployer
 
@@ -238,7 +286,7 @@ class Viewer:
 
         else:
             raise ValueError(
-                f"Unsupported environment: {env}, only 'notebook', 'flask'/'browser' are supported right now."
+                f"Unsupported environment: {env}, only 'notebook', 'browser' are supported right now."
             )
 
     @contextmanager