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

syd/parameters.py

@@ -3,14 +3,13 @@ from dataclasses import dataclass, field
 from abc import ABC, abstractmethod
 from enum import Enum
 from copy import deepcopy
-from warnings import warn
 
 from .support import (
     NoInitialValue,
     ParameterMeta,
     ParameterUpdateError,
-    ParameterUpdateWarning,
     get_parameter_attributes,
+    warn_parameter_update,
 )
 
 T = TypeVar("T")
@@ -433,12 +432,10 @@ class SelectionParameter(Parameter[Any]):
 
         # If value is not found after all checks, reset to first option
         if not value_found:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Value {self.value} not in options, setting to first option ({self.options[0]})",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Value {self.value} not in options, setting to first option ({self.options[0]})",
             )
             self.value = self.options[0]
 
@@ -558,22 +555,18 @@ class MultipleSelectionParameter(Parameter[List[Any]]):
     def _validate_update(self) -> None:
         self.options = self._validate_options(self.options)
         if not isinstance(self.value, (list, tuple)):
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"For parameter {self.name}, value {self.value} is not a list or tuple. Setting to empty list.",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"For parameter {self.name}, value {self.value} is not a list or tuple. Setting to empty list.",
             )
             self.value = []
         if not all(val in self.options for val in self.value):
             invalid = [val for val in self.value if val not in self.options]
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"For parameter {self.name}, value {self.value} contains invalid selections: {invalid}. Setting to empty list.",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"For parameter {self.name}, value {self.value} contains invalid selections: {invalid}. Setting to empty list.",
             )
             self.value = []
         # Keep only unique values while preserving order based on self.options
@@ -652,21 +645,17 @@ class IntegerParameter(Parameter[int]):
 
         if compare_to_range:
             if new_value < self.min:
-                warn(
-                    ParameterUpdateWarning(
-                        self.name,
-                        type(self).__name__,
-                        f"Value {new_value} below minimum {self.min}, clamping",
-                    )
+                warn_parameter_update(
+                    self.name,
+                    type(self).__name__,
+                    f"Value {new_value} below minimum {self.min}, clamping",
                 )
                 new_value = self.min
             if new_value > self.max:
-                warn(
-                    ParameterUpdateWarning(
-                        self.name,
-                        type(self).__name__,
-                        f"Value {new_value} above maximum {self.max}, clamping",
-                    )
+                warn_parameter_update(
+                    self.name,
+                    type(self).__name__,
+                    f"Value {new_value} above maximum {self.max}, clamping",
                 )
                 new_value = self.max
         return int(new_value)
@@ -688,12 +677,10 @@ class IntegerParameter(Parameter[int]):
                 "IntegerParameter must have both min and max bounds",
             )
         if self.min > self.max:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Min value greater than max value, swapping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Min value greater than max value, swapping",
             )
             self.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
@@ -788,21 +775,17 @@ class FloatParameter(Parameter[float]):
 
         if compare_to_range:
             if new_value < self.min:
-                warn(
-                    ParameterUpdateWarning(
-                        self.name,
-                        type(self).__name__,
-                        f"Value {new_value} below minimum {self.min}, clamping",
-                    )
+                warn_parameter_update(
+                    self.name,
+                    type(self).__name__,
+                    f"Value {new_value} below minimum {self.min}, clamping",
                 )
                 new_value = self.min
             if new_value > self.max:
-                warn(
-                    ParameterUpdateWarning(
-                        self.name,
-                        type(self).__name__,
-                        f"Value {new_value} above maximum {self.max}, clamping",
-                    )
+                warn_parameter_update(
+                    self.name,
+                    type(self).__name__,
+                    f"Value {new_value} above maximum {self.max}, clamping",
                 )
                 new_value = self.max
 
@@ -825,12 +808,10 @@ class FloatParameter(Parameter[float]):
                 "FloatParameter must have both min and max bounds",
             )
         if self.min > self.max:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Min value greater than max value, swapping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Min value greater than max value, swapping",
             )
             self.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
@@ -932,31 +913,25 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
         high = self._validate_single(new_value[1])
 
         if low > high:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Low value {low} greater than high value {high}, swapping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Low value {low} greater than high value {high}, swapping",
             )
             low, high = high, low
 
         if low < self.min:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Low value {low} below minimum {self.min}, clamping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Low value {low} below minimum {self.min}, clamping",
             )
             low = self.min
         if high > self.max:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"High value {high} above maximum {self.max}, clamping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"High value {high} above maximum {self.max}, clamping",
             )
             high = self.max
 
@@ -979,12 +954,10 @@ class IntegerRangeParameter(Parameter[Tuple[int, int]]):
                 "IntegerRangeParameter must have both min and max bounds",
             )
         if self.min > self.max:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Min value greater than max value, swapping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Min value greater than max value, swapping",
             )
             self.min, self.max = self.max, self.min
         self.value = self._validate(self.value)
@@ -1102,31 +1075,25 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
         high = self._validate_single(new_value[1])
 
         if low > high:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Low value {low} greater than high value {high}, swapping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Low value {low} greater than high value {high}, swapping",
             )
             low, high = high, low
 
         if low < self.min:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Low value {low} below minimum {self.min}, clamping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Low value {low} below minimum {self.min}, clamping",
             )
             low = self.min
         if high > self.max:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"High value {high} above maximum {self.max}, clamping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"High value {high} above maximum {self.max}, clamping",
             )
             high = self.max
 
@@ -1149,12 +1116,10 @@ class FloatRangeParameter(Parameter[Tuple[float, float]]):
                 "FloatRangeParameter must have both min and max bounds",
             )
         if self.min > self.max:
-            warn(
-                ParameterUpdateWarning(
-                    self.name,
-                    type(self).__name__,
-                    f"Min value greater than max value, swapping",
-                )
+            warn_parameter_update(
+                self.name,
+                type(self).__name__,
+                f"Min value greater than max value, swapping",
             )
             self.min, self.max = self.max, self.min
         self.value = self._validate(self.value)

syd/support.py

@@ -1,5 +1,17 @@
 from abc import ABCMeta
 from typing import Any, List
+from warnings import warn
+from contextlib import contextmanager
+import matplotlib.pyplot as plt
+
+
+@contextmanager
+def plot_context():
+    plt.ioff()
+    try:
+        yield
+    finally:
+        plt.ion()
 
 
 class NoUpdate:
@@ -20,6 +32,9 @@ class NoUpdate:
             and other._noupdate_identifier == self._noupdate_identifier
         )
 
+    def __repr__(self):
+        return "NotUpdated"
+
 
 class NoInitialValue:
     """Singleton class to represent a non-initial value in parameter operations."""
@@ -39,6 +54,9 @@ class NoInitialValue:
             and other._noinitialvalue_identifier == self._noinitialvalue_identifier
         )
 
+    def __repr__(self):
+        return "NotInitialized"
+
 
 # Keep original Parameter class and exceptions unchanged
 class ParameterAddError(Exception):
@@ -110,6 +128,15 @@ class ParameterUpdateWarning(Warning):
         )
 
 
+def warn_parameter_update(
+    parameter_name: str, parameter_type: str, message: str = None
+):
+    """
+    Warn the user that a parameter has been updated to a value behind the scenes.
+    """
+    warn(ParameterUpdateWarning(parameter_name, parameter_type, message))
+
+
 def get_parameter_attributes(param_class) -> List[str]:
     """
     Get all valid attributes for a parameter class.

syd/viewer.py

@@ -7,7 +7,6 @@ from matplotlib.figure import Figure
 from .parameters import ParameterType, ActionType, Parameter
 from .support import NoUpdate, NoInitialValue, ParameterAddError, ParameterUpdateError
 
-
 # Create the singleton instances
 NO_UPDATE = NoUpdate()
 NO_INITIAL_VALUE = NoInitialValue()
@@ -217,24 +216,29 @@ class Viewer:
         """Deploy the app in a notebook or standalone environment"""
         env = env.lower()
         if env == "notebook":
-            from .notebook_deployment import NotebookDeployer
+            # On demand import because the deployers need to import the viewer
+            from .notebook_deployment.deployer import NotebookDeployer
 
             deployer = NotebookDeployer(self, **kwargs)
             deployer.deploy()
             return self
 
         elif env == "browser" or env == "flask":
-            from .flask_deployment import deploy_flask
+            # On demand import because the deployers need to import the viewer
+            from .flask_deployment.deployer import FlaskDeployer
 
-            # Ensure port is None by default if not specified
             if "port" not in kwargs:
                 kwargs["port"] = None
+            if "continuous" in kwargs:
+                kwargs.pop("continuous")
 
-            deployer = deploy_flask(self, **kwargs)
+            deployer = FlaskDeployer(self, **kwargs)
+            deployer.deploy()
             return self
+
         else:
             raise ValueError(
-                f"Unsupported environment: {env}, only 'notebook', 'plotly', 'plotly-inline', and 'flask' are supported right now."
+                f"Unsupported environment: {env}, only 'notebook', 'flask'/'browser' are supported right now."
             )
 
     @contextmanager

syd-1.0.0.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: syd
+Version: 1.0.0
+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: flask
+Requires-Dist: ipykernel
+Requires-Dist: ipympl
+Requires-Dist: ipywidgets
+Requires-Dist: matplotlib
+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'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!
+
+## Installation
+It's easy, just use pip install. The dependencies are light so it should work in most environments.
+```bash
+pip install syd
+```
+
+## Documentation
+The full documentation is available at [shareyourdata.readthedocs.io](https://shareyourdata.readthedocs.io/). It includes a quick start guide, a comprehensive tutorial, and an API reference for the different elements of Syd. If you have any questions or want to suggest improvements to the docs, please let us know on the [github issues page](https://github.com/landoskape/syd/issues)!
+
+## 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
+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=0, max=2)
+viewer.add_float('frequency', value=1.0, min=0.1, max=5)
+
+# env = "browser" # for viewing in a web browser
+env = "notebook" # for viewing within a jupyter notebook
+viewer.deploy(env=env)
+```
+
+### 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:
+
+| Example | Description | Try It! |
+|---------|-------------|---------------|
+| [Basic Tutorial](examples/1-simple_example.ipynb) | A good starting point with detailed explanations of how to use the core elements of Syd. | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/landoskape/syd/blob/main/examples/1-simple_example.ipynb) |
+| [Comprehensive](examples/2a-complex_example.ipynb) | Showcases just about everything you can do with Syd. | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/landoskape/syd/blob/main/examples/2a-complex_example.ipynb) |
+| [Making a Viewer Class](examples/2b-subclass_example.ipynb) | Rewrites the comprehensive example as a class, which is useful when you have complex data processing or callbacks. | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/landoskape/syd/blob/main/examples/2b-subclass_example.ipynb) |
+| [Data Loading](examples/3-data_loading.ipynb) | Showcases different ways to get your data into a Syd viewer. | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/landoskape/syd/blob/main/examples/3-data_loading.ipynb) |
+| [Hierarchical Callbacks](examples/4-hierarchical_callbacks.ipynb) | Demonstrates how to handle complicated callback situations. | [![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) |
+
+
+### 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:
+```python
+import numpy as np
+from matplotlib import pyplot as plt
+from syd import make_viewer
+
+# Suppose you computed some data somewhere (in a script or in a jupyter notebook)
+data = np.random.randn(100, 1000)
+
+# When you write a plot function like this, it'll be able to access the data variable
+def plot(state):
+    fig = plt.figure()
+    ax = fig.add_subplot(111)
+
+    # plot indexes to the data that you created outside the plot function
+    ax.imshow(data[state["index"]])
+    return fig
+
+# 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")
+```
+
+### 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).
+
+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!
+
+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: 
+```python
+import numpy as np
+from syd import Viewer # Much easier to build a Viewer class for hierarchical callbacks
+
+class MouseViewer(Viewer):
+    def __init__(self, mice_names):
+        self.mice_names = mice_names
+
+        self.add_selection("mouse", options=list(mice_names))
+
+        # We don't know how many sessions or neurons to pick from yet!
+        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
+        self.on_change("mouse", self.update_mouse)
+
+        # 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
+        # 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)
+
+    def update_mouse(self, state):
+        # Pseudo code for getting the number of sessions for a given mouse
+        num_sessions = get_num_sessions(state["mouse"])
+
+        # Now we update the number of sessions to pick from
+        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:
+        new_state = self.state
+
+        # Then perform the session update callback!
+        self.update_session(new_state)
+
+    def update_session(self, state):
+        # Pseudo code for getting the number of neurons for a given mouse and session
+        num_neurons = get_num_neurons(state["mouse"], state["session"])
+
+        # Now we update the number of neurons to pick from
+        self.update_integer("neuron", max=num_neurons - 1)
+
+    def plot(self, state):
+        # Pseudo code for plotting the data
+        data = get_data(state["mouse"], state["session"], state["neuron"])
+        fig = plot_the_data(data)
+        return fig
+
+# Now we can create a viewer and deploy it
+viewer = MouseViewer(["Mouse 1", "Mouse 2", "Mouse 3"])
+viewer.deploy(env="browser")
+```
+
+## 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
+- Layout controls
+  - [ ] Improve the display and make it look better
+  - [ ] Add a "save" button that saves the current state of the viewer to a json file
+  - [ ] Add a "load" button that loads the viewer state from a json file
+  - [ ] 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.dist-info/RECORD

@@ -0,0 +1,19 @@
+syd/__init__.py,sha256=LSf7L9CZ7WVB6qb88vX6YgnCffcQLsDdhIggNMEGd10,250
+syd/parameters.py,sha256=dlnYOVsi1CDtC2toVECf0kNBRipVrtUjr6XVX86b5MA,42886
+syd/support.py,sha256=7wztPMaL750opyBDnaYYRVyBR5QUJtVspDzQWpu50rk,6106
+syd/viewer.py,sha256=UYDfH9TNds0CiC3vThINLrMNZE8ikSFqJHgjM8yMD94,49323
+syd/flask_deployment/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+syd/flask_deployment/deployer.py,sha256=w-zuXX1PCnWRa_VCevbQ7yqMTNH5x3Dri-sQQXOF1sM,25110
+syd/flask_deployment/testing_principles.md,sha256=GyULM97sDeie8h3tSPoduOckdMNGyWuwm1RdHo5jzK0,10130
+syd/flask_deployment/static/__init__.py,sha256=ieWE8NKR-APw7h4Ge0ooZGk6wZrneSSs_1cMyTPbQSA,65
+syd/flask_deployment/static/css/styles.css,sha256=gA-Urdq9wmd-XpVcxILxPGlkiOtKtujG7Mw7dWftIVM,5210
+syd/flask_deployment/static/js/viewer.js,sha256=kSY24VGjlQLe-jtPOEU1nE7U0ALC_ZaVzGIBuEXZsTs,27441
+syd/flask_deployment/templates/__init__.py,sha256=ieWE8NKR-APw7h4Ge0ooZGk6wZrneSSs_1cMyTPbQSA,65
+syd/flask_deployment/templates/index.html,sha256=fr1g9IOwNttULhQCIcw_fo0sNpmdgznSGfPStQllR_E,1594
+syd/notebook_deployment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syd/notebook_deployment/deployer.py,sha256=LcKq0Jy_znrVFF7S0uBJrQUWf1hB-NKmDYiq1OG0Jr8,8930
+syd/notebook_deployment/widgets.py,sha256=UbkasRf8wY9beUwpwJYjv9X0Lus3DvgAEIORHwaC-zA,20058
+syd-1.0.0.dist-info/METADATA,sha256=xEpq6sJo2eE6uMZDCwgLwS1yMQd1ZRoz--SWDE4t0F0,13043
+syd-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+syd-1.0.0.dist-info/licenses/LICENSE,sha256=YF6QR6Vjxcg5b_sYIyqkME7FZYau5TfEUGTG-0JeRK0,35129
+syd-1.0.0.dist-info/RECORD,,