solara 1.30.1__py2.py3-none-any.whl → 1.31.0__py2.py3-none-any.whl

solara/website/pages/documentation/getting_started/content/06-reference/95-caching.md

@@ -1,148 +0,0 @@
----
-title: Caching resources for your solara application or dashboard
-description: Solara has a dict-like object at `solara.cache.storage` that can be used to store objects in under a key. So we can use this global
-    object as normal dict.
----
-# Caching
-
-Solara has a dict-like object at `solara.cache.storage` that can be used to store objects in under a key. So we can use this global
-object as normal dict, e.g.:
-
-```python
-import solara
-solara.cache.storage["my-key"] = expensive_function_call()
-assert "my-key" in solara.cache.storage
-```
-
-Note that at any time later on, the key may be removed from this object, as a cache always has a limited capacity.
-
-The `solara.cache.storage` cache object is used by [memoize](/documentation/api/utilities/memoize), if no storage argument is passed to this decorator.
-
-## Types of cache
-
-Solara core comes by default with an in-memory cache using a [LRU](https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)) (Least recently used) strategy. When the
-cache becomes too full, this removes entries used least recently.
-
-The cache is set by default to:
-```python
-solara.cache.storage = solara.cache.Memory(maxsize=128)
-```
-
-Which will remove the least recently used element when the 129th item is added.
-
-The memory cache is also configurable using environment variable:
-```
-$ export SOLARA_CACHE=memory  # already the default
-$ export SOLARA_CACHE_MEMORY_MAX_ITEMS=128  # already the default
-```
-
-## Custom caches
-An infinite cache can be set using:
-
-```python
-solara.cache.storage = {}  # a regular dict
-```
-
-The [cachetools](https://cachetools.readthedocs.io/) project has some caching types that behave like a Python dict, and are compatible with Solara, e.g.:
-
-```python
-import cachetools
-import solara
-solara.cache.storage = cachetools.FIFOCache(maxsize=100)
-```
-
-## Solara-enterprise
-
-With solara-enterprise, we have more cache storage options.
-
-### Memory (byte size based)
-
-The cache will limit the total number of bytes to a set maximum, instead of the number of items as is with the normal 'memory' cache.
-
-This can be set using code:
-
-```python
-import solara
-solara.cache.configure("memory-size")
-# or more explicit
-import solara_enterprise.cache.memory_size
-solara.cache.storage = solara_enterprise.cache.memory_size.MemorySize(
-    max_size="1GB"  # already the default
-)
-```
-
-The 'memory-size' cache can also be configured using environment variables:
-
-```
-$ export SOLARA_CACHE=memory-size
-$ export SOLARA_CACHE_MEMORY_MAX_SIZE=1GB  # already the default
-
-```
-
-
-### Disk cache
-
-This cache will persist the entries to disk, allowing multiple processes to share the same data. This cache type is ideal when using multiple workers on a single node.
-
-This can be set using code:
-
-```python
-import solara
-solara.cache.configure("disk")
-# or more explicit
-import solara_enterprise.cache.disk
-solara.cache.storage = solara_enterprise.cache.disk.Disk(
-    max_size="10GB", path="/home/maarten/.solara/cache"  # already the default
-)
-```
-
-Or configurable using environment variable:
-```
-$ export SOLARA_CACHE=disk
-$ export SOLARA_CACHE_DISK_MAX_SIZE=10GB  # already the default
-$ export SOLARA_CACHE_PATH_=/home/maarten/.solara/cache  # already the default
-```
-
-### Redis cache
-
-This cache will store the entries in a [Redis](https://redis.io/) server, allowing multiple nodes to share the same data. This is ideal in a cluster/distributed configuration.
-
-This can be set using code:
-
-```python
-import solara
-solara.cache.configure("redis")
-# or more explicit
-import solara_enterprise.cache.redis
-# optionally pass in a redis.Client object
-solara.cache.storage = solara_enterprise.cache.redis.Redis()
-```
-
-Or configured using environment variable:
-```
-$ export SOLARA_CACHE=redis
-```
-
-### Multi-level cache
-
-We can chain a few caches to get a multilevel cache. This allows us to get the benefits of the low latency memory cache while sharing it with other workers and nodes.
-
-```python
-import solara
-solara.cache.configure("memory,disk,redis")
-# or more explicit
-import solara_enterprise.cache.multi_level
-import solara_enterprise.cache.disk
-import solara_enterprise.cache.redis
-l1 = solara.cache.Memory()
-l2 = solara_enterprise.cache.disk.Disk()
-l3 = solara_enterprise.cache.redis.Redis()
-solara.cache.storage = solara_enterprise.cache.multi_level.MultiLevel(
-    l1, l2, l3
-)
-```
-
-Or configured using an environment variable:
-```
-$ export SOLARA_CACHE="memory,disk,redis"
-```

solara/website/pages/documentation/getting_started/content/07-deploying/00-overview.md

@@ -1,7 +0,0 @@
----
-title: Overview of how to deploy your Solara application or dashboard
-description: Solara apps can be easily either self hosted, or hosted on a variety of cloud platforms.
----
-# Deploying a solara app
-
-A Solara app can be [self hosted](/documentation/getting_started/deploying/self-hosted) or [cloud hosted](/documentation/getting_started/deploying/cloud-hosted).

solara/website/pages/documentation/getting_started/content/07-deploying/10-self-hosted.md

@@ -1,273 +0,0 @@
----
-title: Deploying and hosting your own Solara app
-description: Solara is compatible with many different hosting solutions, such as Flask, Starlette, FastAPI, and Voila.
----
-# Self hosted deployment
-
- * [Flask](#flask)
- * [Starlette](#flask)
- * [FastAPI](#flask)
- * [Voila](#voila)
- * [Panel](#panel)
- * [Nginx](#nginx)
- * [Docker](#docker)
-
-
-Solara runs on several web frameworks, such as
-
- * [Flask](https://flask.palletsprojects.com/)
- * [Starlette](https://www.starlette.io/) (and thus [FastAPI](https://fastapi.tiangolo.com/))
-
-The most straightforward and well-tested method to deploy Solara is through the `solara run` command:
-
-    $ solara run sol.py --production
-
-which uses Starlette under the hood.
-
-Your `sol.py` file could resemble the following:
-
-```python
-import solara
-
-clicks = solara.reactive(0)
-
-
-@solara.component
-def Page():
-    color = "green"
-    if clicks.value >= 5:
-        color = "red"
-
-    def increment():
-        clicks.value += 1
-        print("clicks", clicks)  # noqa
-
-    solara.Button(label=f"Clicked: {clicks}", on_click=increment, color=color)
-```
-
-
-If you're aiming to integrate Solara with other web frameworks such as [Flask](https://flask.palletsprojects.com/deploying/), [Starlette](https://www.starlette.io/), or [FastAPI](https://fastapi.tiangolo.com/), you normally do not execute `solara run sol.py`.
-Instead, start your chosen web framework as directed by their documentation and configure Solara via environment variables. For instance, instead of running the development server like `solara run sol.py`, set the `SOLARA_APP` environment variable to `sol.py`:
-
-    $ export SOLARA_APP=sol.py
-    # run flask or starlette
-
-or look at the examples below for more detailed instructions per web framework. Note that when solara is used this way it [by default runs in production mode](https://solara.dev/documentation/advanced/understanding/solara-server).
-
-## Flask
-
-For Flask, you can consult [the Flask documentation](https://flask.palletsprojects.com/deploying/).
-
-A common solution is to use [gunicorn](https://gunicorn.org/) as the WSGI HTTP Server.
-
-A typical command would be:
-```
-$ SOLARA_APP=sol.py gunicorn --workers 4 --threads=20 -b 0.0.0.0:8765 solara.server.flask:app
-```
-
-Note that we need at least 1 thread per user due to the use of a websocket.
-
-### Embedding in an existing Flask application
-
-If you already have a Flask app and want to add your Solara app behind a prefix, say `'/solara/'`, you can add the [Blueprint](https://flask.palletsprojects.com/blueprints/) to your existing app as follows.
-
-```python
-from flask import Flask
-import solara.server.flask
-
-app = Flask(__name__)
-app.register_blueprint(solara.server.flask.blueprint, url_prefix="/solara/")
-
-@app.route("/")
-def hello_world():
-    return "<p>Hello, World!</p>"
-```
-
-Save this file as `"app.py"` and run
-
-    $  SOLARA_APP=sol.py flask run
-     * Running on http://127.0.0.1:5000/
-
-If you navigate to [http://127.0.0.1:5000/solara](http://127.0.0.1:5000/solara) you should see the Solara app.
-
-## Starlette
-
-For [Starlette](https://www.starlette.io/) we will assume [uvicorn](http://www.uvicorn.org/) for the ASGI webserver and follow their [deployment documentation](https://www.uvicorn.org/deployment/):
-
-```
-$ SOLARA_APP=sol.py uvicorn --workers 4 --host 0.0.0.0 --port 8765 solara.server.starlette:app
-```
-
-### Embedding in an existing Starlette application
-
-If you already have a Starlette app and want to add your Solara app behind a prefix, say `'/solara/'`, you can mount the Starlette routes for Solara to your existing app as follows.
-
-```python
-from starlette.applications import Starlette
-from starlette.requests import Request
-from starlette.responses import JSONResponse
-from starlette.routing import Mount, Route
-
-import solara.server.starlette
-
-
-def myroot(request: Request):
-    return JSONResponse({"framework": "solara"})
-
-
-routes = [
-    Route("/", endpoint=myroot),
-    Mount("/solara/", routes=solara.server.starlette.routes),
-]
-
-app = Starlette(routes=routes)
-```
-
-Save this file as `"solara_on_starlette.py"` and run
-
-```
-$  SOLARA_APP=sol.py uvicorn solara_on_starlette:app
-...
-INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-...
-```
-
-If you navigate to [http://127.0.0.1:8000/solara](http://127.0.0.1:8000/solara) you should see the Solara app.
-
-## FastAPI
-
-Since [FastAPI](https://fastapi.tiangolo.com/) is built on Starlette, see the section on [Starlette](#starlette) about how to deploy a Starlette app.
-
-### Embedding in an existing FastAPI application
-
-Use `app.mount` to mount the Solara app into your existing FastAPI app.
-
-```python
-from fastapi import FastAPI
-import solara.server.fastapi
-
-app = FastAPI()
-
-
-@app.get("/")
-def read_root():
-    return {"Hello": "World"}
-
-
-app.mount("/solara/", app=solara.server.fastapi.app)
-```
-
-Save this file as `"solara_on_fastapi.py"` and run
-
-```
-$  SOLARA_APP=sol.py uvicorn solara_on_fastapi:app
-...
-INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-...
-```
-
-If you navigate to [http://127.0.0.1:8000/solara](http://127.0.0.1:8000/solara) you should see the Solara app.
-
-
-## Voila
-
-If you use Voila, [you can use those deployment options](https://voila.readthedocs.io/en/stable/deploy.html).
-
-Make sure you run a notebook where you display the app, e.g.
-```python
-@solara.component
-def Page():
-    ...
-element = Page()
-display(element)
-```
-
-Or consider using [Voila-vuetify](https://github.com/voila-dashboards/voila-vuetify).
-
-Solara apps in Voila do not have support for [routing](/documentation/advanced/understanding/routing)/[multipage](/documentation/advanced/howto/multipage).
-
-
-## Panel
-
-[Panel](https://panel.holoviz.org/) supports [IPyWidgets](https://panel.holoviz.org/reference/panes/IPyWidget.html), which
-means we can also embed the resulting widget from Reacton or Solara. See their [section on deployment](https://panel.holoviz.org/user_guide/Server_Deployment.html) and use the following code as an example of how to include a react component.
-```python
-import panel as pn
-import solara
-
-
-@solara.component
-def ButtonClick(label="Hi"):
-    clicks, set_clicks = solara.use_state(0)
-    def increment():
-        set_clicks(clicks + 1)
-    return solara.Button(f"{label}: Clicked {clicks} times", on_click=increment)
-
-# this creates just an element, Panel doesn't know what to do with that
-element = ButtonClick("Solara+Panel")
-# we explicitly ask Reacton to render it, and give us the widget
-button_widget, render_context = reacton.render_fixed(element)
-# mark this panel to be served by the panel server
-pn.panel(button_widget).servable()
-```
-
-For development/testing purposes, run this script as:
-
-    $ panel serve solara_in_panel.py
-
-Solara apps in Panel do not have support for [routing](/documentation/advanced/understanding/routing)/[multipage](/documentation/advanced/howto/multipage).
-
-## Nginx
-
-If you use Nginx as a (reverse) proxy in front of your Python web server, a minimal
-configuration would be:
-
-```
-server {
-    server_name widgetti.io;
-    listen 80
-    location /solara/ {
-            # the local solara server (could be using Starlette/uvicorn)
-            proxy_pass http://localhost:8765/;
-
-            proxy_set_header Host $host;
-            proxy_set_header X-Real-IP $remote_addr;
-            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-            proxy_set_header X-Script-Name /solara;  # informs solara to produce correct urls
-
-            proxy_http_version 1.1;
-            proxy_set_header Upgrade $http_upgrade;
-            proxy_set_header Connection "upgrade";
-            proxy_read_timeout 86400;
-    }
-}
-```
-
-Note that if we use `location /` instead of `location /solara/`, we can skip the `proxy_set_header X-Script-Name /solara` line.
-
-An alternative to using the `X-Script-Name` header with uvicorn, would be to pass the `--root-path` flag, e.g.:
-
-```
-$ SOLARA_APP=sol.py uvicorn --workers 1 --root-path /solara -b 0.0.0.0:8765 solara.server.flask:app
-```
-
-## Docker
-
-There is nothing special about running Solara in Docker. The only things you probably need to change is the interface the server binds to.
-Solara by default binds to localhost, so that it is not accessible from the outside world. Apart from that localhost (or `::1` in case of IPv6)
-might not be available, you probably want the outside world to see your Solara app. For that, you can use `--host=0.0.0.0` or `--host=::` option to bind to all interfaces.
-
-Your Dockerfile could look like:
-
-```Dockerfile
-FROM ....
-
-...
-CMD ["solara", "run", "sol.py", "--host=0.0.0.0", "--production"]
-
-```
-
-For a complete example, you can take a look at:
-  * [https://huggingface.co/spaces/solara-dev/template](https://huggingface.co/spaces/solara-dev/template)
-  * [https://huggingface.co/spaces/giswqs/solara-template/tree/main](https://huggingface.co/spaces/giswqs/solara-template/tree/main)
-  * [https://github.com/opengeos/solara-template](https://github.com/opengeos/solara-template)

solara/website/pages/documentation/getting_started/content/07-deploying/20-cloud-hosted.md

@@ -1,80 +0,0 @@
----
-title: Hosting your Solara app on the cloud
-description: Solara apps can be easily hosted either through our service, or via Ploomber cloud.
----
-# Cloud hosted
-
-## Integrated solution (in development)
-
-Are you interested in a cloud hosted solution?
-
-```bash
-$ solara deploy
-...
-Your app is live on awesomeapp-mystartup-gh.solara.run
-```
-
-Sign up for our waiting list to get early access.
-
-<!-- Begin Mailchimp Signup Form -->
-<link href="//cdn-images.mailchimp.com/embedcode/classic-071822.css" rel="stylesheet" type="text/css">
-<style type="text/css">
-	#mc_embed_signup{background:#fff; clear:left; font:14px Helvetica,Arial,sans-serif;  width:600px;}
-	/* Add your own Mailchimp form style overrides in your site stylesheet or in this style block.
-	   We recommend moving this block and the preceding CSS link to the HEAD of your HTML file. */
-</style>
-<div id="mc_embed_signup">
-    <form action="https://gmail.us13.list-manage.com/subscribe/post?u=1dcdd74de47214edace5b6f49&amp;id=c60b5def86&amp;f_id=00f4c1e2f0" method="post" id="mc-embedded-subscribe-form" name="mc-embedded-subscribe-form" class="validate" target="_blank" novalidate>
-        <div id="mc_embed_signup_scroll">
-        <h2>Sign up for our waiting list</h2>
-        <div class="indicates-required"><span class="asterisk">*</span> indicates required</div>
-<div class="mc-field-group">
-	<label for="mce-EMAIL">Email Address  <span class="asterisk">*</span>
-</label>
-	<input type="email" value="" name="EMAIL" class="required email" id="mce-EMAIL" required>
-	<span id="mce-EMAIL-HELPERTEXT" class="helper_text"></span>
-</div>
-<div class="mc-field-group">
-	<label for="mce-FNAME">First Name </label>
-	<input type="text" value="" name="FNAME" class="" id="mce-FNAME">
-	<span id="mce-FNAME-HELPERTEXT" class="helper_text"></span>
-</div>
-<div class="mc-field-group">
-	<label for="mce-LNAME">Last Name </label>
-	<input type="text" value="" name="LNAME" class="" id="mce-LNAME">
-	<span id="mce-LNAME-HELPERTEXT" class="helper_text"></span>
-</div>
-<div class="mc-field-group">
-	<label for="mce-COMPANY">Company </label>
-	<input type="text" value="" name="COMPANY" class="" id="mce-COMPANY">
-	<span id="mce-COMPANY-HELPERTEXT" class="helper_text"></span>
-</div>
-
-<div class="mc-field-group">
-	<label for="mce-WHYCLOUD">Why are you interested in a cloud hosted solution? </label>
-	<input type="text" value="" name="WHYCLOUD" class="" id="mce-WHYCLOUD">
-	<span id="mce-WHYCLOUD-HELPERTEXT" class="helper_text"></span>
-</div>
-
-<div id="mce-responses" class="clear foot">
-    <div class="response" id="mce-error-response" style="display:none"></div>
-    <div class="response" id="mce-success-response" style="display:none"></div>
-</div>    <!-- real people should not fill this in and expect good things - do not remove this or risk form bot signups-->
-<div style="position: absolute; left: -5000px;" aria-hidden="true"><input type="text" name="b_1dcdd74de47214edace5b6f49_c60b5def86" tabindex="-1" value=""></div>
-    <div class="optionalParent">
-        <div class="clear foot">
-            <input type="submit" value="Sign up" name="subscribe" id="mc-embedded-subscribe" class="button">
-        </div>
-    </div>
-</div>
-</form>
-</div>
-<script type='text/javascript' src='//s3.amazonaws.com/downloads.mailchimp.com/js/mc-validate.js'></script><script type='text/javascript'>(function($) {window.fnames = new Array(); window.ftypes = new Array();fnames[0]='EMAIL';ftypes[0]='email';fnames[1]='FNAME';ftypes[1]='text';fnames[2]='LNAME';ftypes[2]='text';fnames[3]='ADDRESS';ftypes[3]='address';fnames[4]='PHONE';ftypes[4]='phone';fnames[5]='BIRTHDAY';ftypes[5]='birthday';fnames[6]='USECASE';ftypes[6]='text';fnames[7]='COMPANY';ftypes[7]='text';fnames[8]='POSITION';ftypes[8]='text';}(jQuery));var $mcj = jQuery.noConflict(true);</script>
-<!--End mc_embed_signup-->
-
-
-## Ploomber Cloud
-
-You can use [Ploomber Cloud](https://www.platform.ploomber.io) to deploy Solara apps for free (no credit card required).
-
-To learn more, check out their [documentation.](https://docs.cloud.ploomber.io/en/latest/apps/solara.html)

solara/website/pages/documentation/getting_started/content/80-what-is-lab.md

@@ -1,7 +0,0 @@
----
-title: What is Solara.lab?
-description: Solara lab is a subpackage in solara containing Components, hooks and parts of Solara that are slightly experimental.
----
-# What is Solara lab?
-
-Solara lab is a subpackage in solara containing Components, hooks and parts of Solara that are slightly experimental.

solara/website/pages/documentation/getting_started/content/90-troubleshoot.md

@@ -1,26 +0,0 @@
----
-title: Troubleshoot issues with your Solara application
-description: It is common to run into some issues when developing your application. See here for best practices for troubleshooting anything you run into.
----
-# Troubleshoot
-
-## Issues in Jupyter
-
-The most common issue in the Jupyter notebook, or Jupyter Lab happens when the notebook server and the kernel do not share the same Python environment. When you install solara via the notebook (e.g. `!pip install solara`), it will install the ipyvue and ipyvuetify libraries, two of its dependencies. These libraries will get installed in the Python environment of your Python kernel.
-
-If your Jupyter notebook or Jupyter Lab server runs in a different Python environment, your browser will not load the Javascript libraries it needs to. In order to get the server to provide these libraries to your browser, we also need to install ipyvue and ipyvuetify in the Python environment of your server.
-
-For instance, running the following in AWS SageMaker, will give you information about the Python environment of the kernel.
-
-```python
->>> import sys
->>> sys.executable
-'/home/ec2-user/anaconda3/envs/python3/bin/python'
-```
-
-While if we inspect the output of `!ps aux | grep jupyter`, we see that the notebook server is using the Python executable at `/home/ec2-user/anaconda3/envs/JupyterSystemEnv/bin/python3.7`.
-
-The solution is to run `!/home/ec2-user/anaconda3/envs/JupyterSystemEnv/bin/python3.7 -m pip install ipyvue ipyvuetify`, and refresh your browser.
-
-The function `solara.check_jupyter()` will perform these checks for you and tell you what to do. However, if it fails and you
-end up in this documentation, we should try to improve it by opening an [Issue on GitHub](https://github.com/widgetti/solara/issues/new).

solara/website/pages/docutils.py

@@ -1,38 +0,0 @@
-import inspect
-
-import solara
-from solara.alias import rw
-from solara.components import Markdown
-
-
-@solara.component
-def Sample(code, component):
-    locals = globals().copy()
-    exec(code, locals)
-    c = locals[component]
-    with rw.VBox() as main:
-        Markdown(
-            f"""
-```python
-{code}
-```
-"""
-        )
-        c()
-    return main
-
-
-@solara.component
-def IncludeComponent(component, pre="", highlight=[], **kwargs):
-    code = inspect.getsource(component.f)
-    with rw.VBox(layout={"padding": "20px", "max_width": "1024px", "border": "1px #333 solid"}) as main:
-        Markdown(
-            f"""
-```python
-{pre}{code}
-```
-""",
-            highlight=highlight,
-        )
-        component(**kwargs)
-    return main