solara-ui 1.31.0__tar.gz

solara_ui-1.31.0/.gitignore

@@ -0,0 +1,89 @@
+*.o
+*.so
+*.mkv
+*.mk4
+#/*.png
+*.eps
+*.pgm
+*.pdf
+*.fld
+*.vtk
+*.mp4
+*/**/*.pyc
+*.pyc
+jenkins/jenkins.war
+/nosetests.xml
+/.idea
+misc/experiments/
+/.coverage
+/coverage.xml
+
+
+Untitled*.ipynb
+
+/experiments/*
+/htmlcov
+
+InterestingSubspacesNew.txt
+Makefile.in
+config.guess
+config.sub
+libtool
+ltmain.sh
+m4/libtool.m4
+m4/ltoptions.m4
+m4/ltversion.m4
+m4/lt~obsolete.m4
+aclocal.m4
+autom4te.cache
+config.h
+config.h.in
+config.log
+config.status
+configure
+depcomp
+install-sh
+missing
+src/.deps/
+src/.libs
+src/Makefile
+src/Makefile.in
+src/libsubfind.a
+subspacefind*.tar.gz
+src/subspacefind?la*
+**/*.pyc
+data/*
+build/
+doc
+docs/build
+meeting
+#misc
+/**/.DS_Store
+/**/.ipynb_checkpoints
+#app
+dist
+lib
+python/.idea
+test/.idea
+venv
+.venv
+tmp
+python/vaex/version.py # gets generated
+**/*.egg-info/
+.eggs/
+bin/.idea
+*.npy
+__pycache__
+.vscode
+
+# output file from the docs
+build/
+
+./tmp
+./examples
+node_modules
+packages/assets/cdn
+packages/assets/dist/*
+
+solara-env
+states

solara_ui-1.31.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Maarten A. Breddels
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

solara_ui-1.31.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.3
+Name: solara-ui
+Version: 1.31.0
+Dynamic: Summary
+Project-URL: Home, https://www.github.com/widgetti/solara
+Project-URL: Documentation, https://solara.dev
+Author-email: "Maarten A. Breddels" <maartenbreddels@gmail.com>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2022 Maarten A. Breddels
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: humanize
+Requires-Dist: ipyvue>=1.9.0
+Requires-Dist: ipyvuetify>=1.6.10
+Requires-Dist: ipywidgets>=7.7
+Requires-Dist: reacton>=1.7.1
+Requires-Dist: requests
+Provides-Extra: all
+Requires-Dist: solara-ui[cache]; extra == 'all'
+Requires-Dist: solara-ui[extra]; extra == 'all'
+Requires-Dist: solara-ui[markdown]; extra == 'all'
+Provides-Extra: cache
+Requires-Dist: cachetools; extra == 'cache'
+Provides-Extra: extra
+Requires-Dist: numpy; extra == 'extra'
+Requires-Dist: pillow; extra == 'extra'
+Provides-Extra: markdown
+Requires-Dist: markdown; extra == 'markdown'
+Requires-Dist: pygments; extra == 'markdown'
+Requires-Dist: pygments==2.10; (python_version < '3.7') and extra == 'markdown'
+Requires-Dist: pymdown-extensions; extra == 'markdown'
+Description-Content-Type: text/markdown
+
+**A Pure Python, React-style Framework for Scaling Your Jupyter and Web Apps**
+
+[![solara logo](https://solara.dev/static/assets/images/logo.svg)](https://solara.dev)
+
+Come chat with us on [Discord](https://discord.solara.dev) to ask questions or share your thoughts or creations!
+
+[![Discord Shield](https://discordapp.com/api/guilds/1106593685241614489/widget.png?style=banner2)](https://discord.solara.dev)
+
+
+
+## Introducing Solara
+
+While there are many Python web frameworks out there, most are designed for small data apps or use paradigms unproven for larger scale. Code organization, reusability, and state tend to suffer as apps grow in complexity, resulting in either spaghetti code or offloading to a React application.
+
+Solara addresses this gap. Using a React-like API, we don't need to worry about scalability. React has already proven its ability to support the world's largest web apps.
+
+Solara uses a pure Python implementation of React (Reacton), creating ipywidget-based applications. These apps work both inside the Jupyter Notebook and as standalone web apps with frameworks like FastAPI. This paradigm enables component-based code and incredibly simple state management.
+
+By building on top of ipywidgets, we automatically leverage an existing ecosystem of widgets and run on many platforms, including JupyterLab, Jupyter Notebook, Voilà, Google Colab, DataBricks, JetBrains Datalore, and more.
+
+We care about developer experience. Solara will give your hot code reloading and type hints for faster development.
+
+## Installation
+
+Run:
+```
+pip install solara
+```
+
+Or follow the [Installation instructions](https://solara.dev/documentation/getting_started/installing) for more detailed instructions.
+
+## First script
+
+Put the following Python snippet in a file (we suggest `sol.py`), or put it in a Jupyter notebook cell:
+
+```python
+import solara
+
+# Declare reactive variables at the top level. Components using these variables
+# will be re-executed when their values change.
+sentence = solara.reactive("Solara makes our team more productive.")
+word_limit = solara.reactive(10)
+
+
+@solara.component
+def Page():
+    # Calculate word_count within the component to ensure re-execution when reactive variables change.
+    word_count = len(sentence.value.split())
+
+    solara.SliderInt("Word limit", value=word_limit, min=2, max=20)
+    solara.InputText(label="Your sentence", value=sentence, continuous_update=True)
+
+    # Display messages based on the current word count and word limit.
+    if word_count >= int(word_limit.value):
+        solara.Error(f"With {word_count} words, you passed the word limit of {word_limit.value}.")
+    elif word_count >= int(0.8 * word_limit.value):
+        solara.Warning(f"With {word_count} words, you are close to the word limit of {word_limit.value}.")
+    else:
+        solara.Success("Great short writing!")
+
+
+# The following line is required only when running the code in a Jupyter notebook:
+Page()
+```
+
+Run from the command line in the same directory where you put your file (`sol.py`):
+
+```bash
+$ solara run sol.py
+Solara server is starting at http://localhost:8765
+```
+
+Or copy-paste this to a Jupyter notebook cell and execute it (the `Page()` expression at the end
+will cause it to automatically render the component in the notebook).
+
+See this snippet run live at https://solara.dev/documentation/getting_started
+
+## Demo
+
+The following demo app can be used to explore a dataset (buildin or upload yourself) using
+a scatter plot. The plot can be interacted with to filter the dataset, and the filtered dataset can
+be downloaded.
+
+ * [Source code](https://github.com/widgetti/solara/blob/master/solara/website/pages/apps/scatter.py)
+
+### Running in solara-server
+
+The solara server is build on top of Starlette/FastAPI and runs standalone. Ideal for production use.
+
+![fastapi](https://global.discourse-cdn.com/standard11/uploads/jupyter/original/2X/9/9442fc70e2a1fcd201f4f900fa073698a1f8c937.gif)
+
+
+### Running in Jupyter
+
+By building on top of ipywidgets, we automatically leverage an existing ecosystem of widgets and run on many platforms, including JupyterLab, Jupyter Notebook, Voilà, Google Colab, DataBricks, JetBrains Datalore, and more. This means our app can also run in Jupyter:
+
+![jupyter](https://global.discourse-cdn.com/standard11/uploads/jupyter/original/2X/8/8bc875c0c3845ae077168575a4f8a49cf1b35bc6.gif)
+
+## Resources
+
+Visit our main website or jump directly to the introduction
+
+[![Introduction](https://dabuttonfactory.com/button.png?t=Introduction&f=Open+Sans-Bold&ts=20&tc=fff&hp=45&vp=12&c=8&bgt=unicolored&bgc=f19f41)](https://solara.dev/documentation)
+[![Quickstart](https://dabuttonfactory.com/button.png?t=Quickstart&f=Open+Sans-Bold&ts=20&tc=fff&hp=45&vp=12&c=8&bgt=unicolored&bgc=f19f41)](https://solara.dev/documentation/getting_started)
+
+*Note that the solara.dev website is created using Solara*

solara_ui-1.31.0/README.md

@@ -0,0 +1,106 @@
+**A Pure Python, React-style Framework for Scaling Your Jupyter and Web Apps**
+
+[![solara logo](https://solara.dev/static/assets/images/logo.svg)](https://solara.dev)
+
+Come chat with us on [Discord](https://discord.solara.dev) to ask questions or share your thoughts or creations!
+
+[![Discord Shield](https://discordapp.com/api/guilds/1106593685241614489/widget.png?style=banner2)](https://discord.solara.dev)
+
+
+
+## Introducing Solara
+
+While there are many Python web frameworks out there, most are designed for small data apps or use paradigms unproven for larger scale. Code organization, reusability, and state tend to suffer as apps grow in complexity, resulting in either spaghetti code or offloading to a React application.
+
+Solara addresses this gap. Using a React-like API, we don't need to worry about scalability. React has already proven its ability to support the world's largest web apps.
+
+Solara uses a pure Python implementation of React (Reacton), creating ipywidget-based applications. These apps work both inside the Jupyter Notebook and as standalone web apps with frameworks like FastAPI. This paradigm enables component-based code and incredibly simple state management.
+
+By building on top of ipywidgets, we automatically leverage an existing ecosystem of widgets and run on many platforms, including JupyterLab, Jupyter Notebook, Voilà, Google Colab, DataBricks, JetBrains Datalore, and more.
+
+We care about developer experience. Solara will give your hot code reloading and type hints for faster development.
+
+## Installation
+
+Run:
+```
+pip install solara
+```
+
+Or follow the [Installation instructions](https://solara.dev/documentation/getting_started/installing) for more detailed instructions.
+
+## First script
+
+Put the following Python snippet in a file (we suggest `sol.py`), or put it in a Jupyter notebook cell:
+
+```python
+import solara
+
+# Declare reactive variables at the top level. Components using these variables
+# will be re-executed when their values change.
+sentence = solara.reactive("Solara makes our team more productive.")
+word_limit = solara.reactive(10)
+
+
+@solara.component
+def Page():
+    # Calculate word_count within the component to ensure re-execution when reactive variables change.
+    word_count = len(sentence.value.split())
+
+    solara.SliderInt("Word limit", value=word_limit, min=2, max=20)
+    solara.InputText(label="Your sentence", value=sentence, continuous_update=True)
+
+    # Display messages based on the current word count and word limit.
+    if word_count >= int(word_limit.value):
+        solara.Error(f"With {word_count} words, you passed the word limit of {word_limit.value}.")
+    elif word_count >= int(0.8 * word_limit.value):
+        solara.Warning(f"With {word_count} words, you are close to the word limit of {word_limit.value}.")
+    else:
+        solara.Success("Great short writing!")
+
+
+# The following line is required only when running the code in a Jupyter notebook:
+Page()
+```
+
+Run from the command line in the same directory where you put your file (`sol.py`):
+
+```bash
+$ solara run sol.py
+Solara server is starting at http://localhost:8765
+```
+
+Or copy-paste this to a Jupyter notebook cell and execute it (the `Page()` expression at the end
+will cause it to automatically render the component in the notebook).
+
+See this snippet run live at https://solara.dev/documentation/getting_started
+
+## Demo
+
+The following demo app can be used to explore a dataset (buildin or upload yourself) using
+a scatter plot. The plot can be interacted with to filter the dataset, and the filtered dataset can
+be downloaded.
+
+ * [Source code](https://github.com/widgetti/solara/blob/master/solara/website/pages/apps/scatter.py)
+
+### Running in solara-server
+
+The solara server is build on top of Starlette/FastAPI and runs standalone. Ideal for production use.
+
+![fastapi](https://global.discourse-cdn.com/standard11/uploads/jupyter/original/2X/9/9442fc70e2a1fcd201f4f900fa073698a1f8c937.gif)
+
+
+### Running in Jupyter
+
+By building on top of ipywidgets, we automatically leverage an existing ecosystem of widgets and run on many platforms, including JupyterLab, Jupyter Notebook, Voilà, Google Colab, DataBricks, JetBrains Datalore, and more. This means our app can also run in Jupyter:
+
+![jupyter](https://global.discourse-cdn.com/standard11/uploads/jupyter/original/2X/8/8bc875c0c3845ae077168575a4f8a49cf1b35bc6.gif)
+
+## Resources
+
+Visit our main website or jump directly to the introduction
+
+[![Introduction](https://dabuttonfactory.com/button.png?t=Introduction&f=Open+Sans-Bold&ts=20&tc=fff&hp=45&vp=12&c=8&bgt=unicolored&bgc=f19f41)](https://solara.dev/documentation)
+[![Quickstart](https://dabuttonfactory.com/button.png?t=Quickstart&f=Open+Sans-Bold&ts=20&tc=fff&hp=45&vp=12&c=8&bgt=unicolored&bgc=f19f41)](https://solara.dev/documentation/getting_started)
+
+*Note that the solara.dev website is created using Solara*

solara_ui-1.31.0/prefix/etc/jupyter/jupyter_notebook_config.d/solara.json

@@ -0,0 +1,7 @@
+{
+  "NotebookApp": {
+    "nbserver_extensions": {
+      "solara.server.jupyter.server_extension": true
+    }
+  }
+}

solara_ui-1.31.0/prefix/etc/jupyter/jupyter_server_config.d/solara.json

@@ -0,0 +1,7 @@
+{
+  "ServerApp": {
+    "jpserver_extensions": {
+      "solara.server.jupyter.server_extension": true
+    }
+  }
+}

solara_ui-1.31.0/pyproject.toml

@@ -0,0 +1,95 @@
+[build-system]
+requires = ["hatchling==1.22.2"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "solara-ui"
+readme = "README.md"
+authors = [{name = "Maarten A. Breddels", email = "maartenbreddels@gmail.com"}]
+license = {file = "LICENSE"}
+classifiers = ["License :: OSI Approved :: MIT License"]
+dynamic = ["version", "description"]
+packages = [
+    { include = "solara" }
+]
+dependencies = [
+    "reacton>=1.7.1",
+    "ipywidgets>=7.7",
+    "ipyvuetify>=1.6.10",
+    "ipyvue>=1.9.0",
+    "requests",
+    "humanize",
+]
+
+[project.urls]
+Home = "https://www.github.com/widgetti/solara"
+Documentation = "https://solara.dev"
+
+[tool.hatch.build.targets.wheel.shared-data]
+"prefix/etc/jupyter" = "etc/jupyter"
+
+[tool.hatch.version]
+path = "solara/__init__.py"
+
+# we ignore build/ but on the website we add solara/website/build
+# when using SSG
+[tool.hatch.build]
+ignore-vcs = true
+
+[tool.hatch.build.targets.wheel]
+include = [
+    "solara",
+    "prefix",
+    "packages/solara-widget-manager/LICENSE.voila.txt",
+]
+exclude = ["packages"]
+
+[tool.hatch.build.targets.sdist]
+# unclear from hatch docs, but README.md and LICENSE are included by default
+# even when we explicitly have an include list
+include = [
+    "solara",
+    "tests",
+    "prefix",
+    "packages/solara-widget-manager/LICENSE.voila.txt",
+]
+# and even when we have an include list, we still need to exclude
+# packages (which I think makes no sense)
+exclude = ["packages"]
+
+[project.optional-dependencies]
+all = [
+    "solara-ui[markdown]",
+    "solara-ui[cache]",
+    "solara-ui[extra]",
+]
+
+markdown = [
+    "markdown",
+    "pymdown-extensions",
+    "pygments",
+    "pygments==2.10; python_version < '3.7'",
+]
+
+cache = [
+    "cachetools"
+]
+
+extra = [
+    "numpy",
+    "pillow",
+]
+
+[tool.ruff]
+fix = false
+line-length = 160
+lint.ignore = ["E402"]
+
+[tool.pytest.ini_options]
+addopts = "--ignore=tests/integration/app_widget.py  --ignore=tests/unit/solara_test_apps"
+timeout = 180
+
+
+[tool.codespell]
+skip='equis-in-vidi.md,substiterat-vati.md,.*,solara/website/build,*.svg,highlight-dark.css,packages/**/dist/*,node_modules,packages/solara-assets,package*.json,tsconfig.tsbuildinfo,*.csv'

solara_ui-1.31.0/solara/__init__.py

@@ -0,0 +1,124 @@
+"""Build webapps using IPywidgets"""
+
+__version__ = "1.31.0"
+github_url = "https://github.com/widgetti/solara"
+git_branch = "master"
+
+
+from . import comm  # noqa: F401
+
+
+def _using_solara_server():
+    import sys
+
+    if "solara.server" in sys.modules:
+        return True
+    if sys.argv[0].split("/")[-1] == "solara":
+        return True
+    return False
+
+
+# isort: skip_file
+# ruff: noqa: F401 F403
+from reacton import (
+    component,
+    component_interactive,
+    value_component,
+    create_context,
+    get_widget,
+    get_context,
+    make,
+    provide_context,
+    render,
+    render_fixed,
+    use_context,
+    use_effect,
+    use_exception,
+    use_memo,
+    use_reducer,
+    use_ref,
+    use_side_effect,
+    use_state,
+    use_state_widget,
+)
+from reacton.core import Element
+
+try:
+    import ipyvuetify.components as v  # type: ignore
+except ModuleNotFoundError:
+    # backwards compatibility
+    import reacton.ipyvuetify as v  # type: ignore
+from . import util
+
+from .reactive import *
+
+from .datatypes import *
+from .hooks import *
+from .cache import memoize
+from . import cache
+
+# TODO: components re-exports v, we should use __all__ in components/misc.py
+from .components import *  # type: ignore
+from .components import _component_vue
+
+from .routing import use_route, use_router, use_route_level, find_route, use_pathname, resolve_path
+from .autorouting import generate_routes, generate_routes_directory, RenderPage, RoutingProvider, DefaultLayout
+from .checks import check_jupyter
+from .scope import get_kernel_id, get_session_id
+
+
+def display(*objs, **kwargs):
+    """Display a Python object in the current component.
+
+    ## Supported objects
+
+    Any object that can be displayed in the Jupyter notebook can be displayed in Solara
+    as well. This means that plotly, pandas, vaex and other libraries that have
+    a display function will work out of the box in Solara.
+
+    However, if you require callback functions, use the specific Solara components, e.g.:
+
+      * [Plotly](/documentation/components/viz/plotly)
+      * [Altair](/documentation/components/viz/altair)
+      * [Matplotlib](/documentation/components/viz/matplotlib)
+      * [Dataframe](/documentation/components/data/dataframe)
+
+    ```solara
+    import solara
+    import pandas as pd
+    import plotly.express as px
+
+    df = px.data.gapminder()
+    fig = px.scatter(df, x="gdpPercap", y="lifeExp")
+    button = solara.Button("Click me")
+
+    @solara.component
+    def Page():
+
+        # You can use solara.display directly
+        solara.display(fig)
+
+        # Or use the IPython display function, which is in the global scope
+        # in Jupyter and Solara
+        display(df)
+
+        with solara.Card("Some card"):
+            # you can use display to add existing elements to the parent's
+            # children
+            display(button)
+    ```
+    Note that this is a dispatch call to the
+    [IPython display function](https://ipython.readthedocs.io/en/stable/api/generated/IPython.display.html#IPython.display.display),
+    with a slimmer API. The main purpose of this function is the have type safety, since tools like mypy do now know about
+    the existence of the IPython display function, and will complain if you use it without importing it.
+    Since solara is always imported, this saves you from having to import IPython in your code.
+
+    ## Arguments
+
+     * `objs`: The objects to display.
+     * `kwargs`: Keyword arguments to pass to the IPython display function.
+
+    """
+    from IPython.display import display as ipy_display
+
+    ipy_display(*objs, **kwargs)