Solara

https://github.com/widgetti/solara
Admin
Solara is a pure Python, React-style framework for building scalable web applications and Jupyter...
Tokens:73,225
Snippets:871
Trust Score:8.1
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Solara Server with all optional dependencies

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install the solara-server package along with all its optional dependencies.

```bash
pip install "solara-server[all]"
```

--------------------------------

### Install Solara Server with Flask backend

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install the solara-server package with the Flask backend.

```bash
pip install "solara-server[flask]"
```

--------------------------------

### Install Solara with OAuth Support

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/30-enterprise/10-oauth.md

Install Solara and Solara Enterprise with authentication support using pip.

```bash
$ pip install solara solara-enterprise[auth]
```

--------------------------------

### Install Solara Server with Starlette backend

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install the solara-server package with the Starlette backend, recommended for deployments.

```bash
pip install "solara-server[starlette]"
```

--------------------------------

### Install Solara UI with markdown support

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install the solara-ui package with added support for markdown rendering.

```bash
pip install "solara-ui[markdown]"
```

--------------------------------

### Install Solara Server

Source: https://github.com/widgetti/solara/blob/master/packages/solara-server/README.md

Install the solara-server package with starlette and dev dependencies.

```bash
pip install solara-server[starlette,dev]
```

--------------------------------

### Airgapped Solara Installation Steps

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

A multi-step process for installing Solara in an environment without internet access. It involves downloading wheels, packaging them, transferring, and then installing locally.

```bash
# Download the required wheels from pypi.
pip wheel --wheel-dir solara-air-gapped "solara[assets]"
# Zip them in a tarball.
tar zcfv solara-air-gapped.tar.gz solara-air-gapped
# Copy the tarball to your server.
scp solara-air-gapped.tar.gz yourusername@youmachine:~/solara-air-gapped.tar.gz
# ssh into your server.
ssh yourusername@yourmachine
...
#  Unzip the tarball.
tar zxfv solara-air-gapped.tar.gz
# Install all wheels.
pip install solara-air-gapped/*.whl
```

--------------------------------

### Install Solara Server

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/20-understanding/50-solara-server.md

Install the solara server with starlette support. You can also install the full solara package to get all solara related packages.

```bash
pip install "solara-server[starlette]"
# pip install solara # to get all solara packages
```

--------------------------------

### Install Solara UI with caching support

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install the solara-ui package with added support for caching functionalities.

```bash
pip install "solara-ui[cache]"
```

--------------------------------

### Install Solara UI with all optional dependencies

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install the solara-ui package, which contains UI components and utilities, along with all its optional dependencies.

```bash
pip install "solara-ui[all]"
```

--------------------------------

### Install Solara Development Dependencies with uv

Source: https://github.com/widgetti/solara/blob/master/AGENTS.md

Use uv to create a virtual environment and install all development dependencies for the Solara project.

```bash
# Create venv with Python 3.11
uv venv .venv --python 3.11

# Install all dev dependencies
uv pip install -r requirements-dev.txt --python .venv/bin/python
```

--------------------------------

### Run Solara Server with uv

Source: https://github.com/widgetti/solara/blob/master/AGENTS.md

Start the Solara development server using uv.

```bash
uv run solara run sol.py
```

--------------------------------

### Install Solara for App Mode

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/00-quickstart.md

Command to install necessary packages for running Solara as a standalone app.

```bash
$ pip install qtpy PySide6
```

--------------------------------

### Local Development Installation

Source: https://github.com/widgetti/solara/blob/master/packages/solara-vuetify3-app/README.md

Install and build the Solara Vuetify3 App bundle for local development. Use `npm run devlink` to ensure the Solara CDN proxy picks up the bundle locally.

```bash
npm install
npm run build
npm run devlink
```

--------------------------------

### Install Solara Server with development dependencies

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install the solara-server package with development dependencies, enabling features like hot reloading.

```bash
pip install "solara-server[dev]"
```

--------------------------------

### Clone Solara and install development dependencies

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/40-development/10-setup.md

Clone the Solara repository and install the necessary development dependencies. This is the initial step for setting up a development environment.

```bash
git clone git@github.com:widgetti/solara.git
cd solara
pip install -r requirements-dev.txt
```

--------------------------------

### Install Solara

Source: https://github.com/widgetti/solara/blob/master/packages/solara-meta/main.README.md

Use pip to install the Solara package. For more detailed instructions, refer to the official documentation.

```bash
pip install solara
```

--------------------------------

### Install bleeding-edge Solara from GitHub

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install the latest unreleased version of Solara directly from its GitHub repository using pip.

```bash
pip install "solara @ git+https://github.com/widgetti/solara"
```

--------------------------------

### Install pytest-ipywidgets

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Use this command for a minimal installation of pytest-ipywidgets for testing ipywidgets.

```bash
pip install "pytest-ipywidgets"
```

--------------------------------

### Pre-install Solara assets for air-gapped environments

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install Solara with its assets included to avoid fetching them from a CDN, suitable for air-gapped or firewalled networks.

```bash
pip install "solara[assets]"
```

--------------------------------

### Install Solara Enterprise

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/70-search.md

Install the `solara-enterprise` package using pip to enable advanced features like search.

```bash
pip install solara-enterprise
```

--------------------------------

### Development Installation for Solara Vuetify App

Source: https://github.com/widgetti/solara/blob/master/packages/solara-vuetify-app/README.md

Use these commands for a development installation to ensure the Solara CDN proxy picks up the bundle locally.

```bash
$ npm install
$ npm run build
$ npm run devlink
```

--------------------------------

### Install pytest-ipywidgets with Notebook

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install pytest-ipywidgets with a compatible version of Notebook for testing.

```bash
pip install "pytest-ipywidgets[notebook]"
```

--------------------------------

### Start Python HTTP Server

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/10-howto/40-embed.md

Command to start a simple HTTP server using Python's standard library. This is used to serve the main HTML page containing the Solara iframe.

```bash
python -m http.server
Serving HTTP on :: port 8000 (http://[::]:8000/) ...
```

--------------------------------

### Install Data Science Packages

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/04-tutorials/_data_science.ipynb

Install the necessary libraries, plotly and pandas, for data visualization and manipulation.

```bash
$ pip install plotly pandas
```

--------------------------------

### Basic Solara App Example

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/01-introduction.md

This is a minimal Solara application that displays a button. Clicking the button increments a counter. This example can be run in a Jupyter notebook or as a standalone web application using `solara run`.

```solara
import solara

clicks = solara.reactive(0)


@solara.component
def Page():
    def increase_clicks():
        clicks.value += 1

    solara.Button(label=f"Clicked {clicks} times", on_click=increase_clicks)

# in the Jupyter notebook, uncomment the next line:
# display(Page())
```

--------------------------------

### Solara Context Menu Example

Source: https://context7.com/widgetti/solara/llms.txt

Demonstrates how to use solara.lab.ContextMenu for right-click menus. The activator is an image, and the menu contains buttons for actions.

```python
import solara
import solara.lab

@solara.component
def Page():
    image = solara.Image("/static/public/beach.jpeg", width="300px")

    # Right-click context menu
    with solara.lab.ContextMenu(activator=image):
        with solara.Column(gap="0px"):
            solara.Button("Save image", text=True, icon_name="mdi-content-save")
            solara.Button("Copy link", text=True, icon_name="mdi-link")
            solara.Button("Open in new tab", text=True, icon_name="mdi-open-in-new")
```

--------------------------------

### Install pytest-ipywidgets with Voila

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install pytest-ipywidgets along with a compatible version of Voila for testing.

```bash
pip install "pytest-ipywidgets[voila]"
```

--------------------------------

### Install pytest-ipywidgets and Playwright

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/10-howto/30-testing.md

Install the necessary testing tools. Use '[solara]' for Solara-specific testing or '[all]' for broader Jupyter environment support.

```bash
$ pip install "pytest-ipywidgets[solara]"  # or "pytest-ipywidgets[all]" if you also want to test with Jupyter Lab, Jupyter Notebook and Voila.
$ playwright install chromium
```

--------------------------------

### Install Solara Package

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/10-howto/10-multipage.md

Install the Solara application locally in editable mode using pip. This command should be run from the root directory of the created Solara project.

```bash
$ (cd solara-test-portal; pip install -e .)
```

--------------------------------

### Run Solara App from Command Line

Source: https://github.com/widgetti/solara/blob/master/packages/solara-meta/main.README.md

Execute a Solara Python file from the command line to start the Solara server. The server will be accessible at http://localhost:8765.

```bash
$ solara run sol.py
Solara server is starting at http://localhost:8765
```

--------------------------------

### Install Solara SSG and Playwright

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/60-static-site-generation.md

Install the Solara enterprise package with SSG support and Playwright for Python. This is a prerequisite for using the static site generation feature.

```bash
$ pip solara-enterprise[ssg]
$ playwright install
```

--------------------------------

### Example Directory Layout for Assets

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/41-asset-files.md

Illustrates a typical project structure where the 'assets' directory is placed alongside the 'pages' directory to manage custom files.

```tree
├── pages
│   ├── 01-landing-page.md
│   ├── 02-some_app.py
└── public
    └── beach.jpeg
└── assets
    ├── custom.css
    ├── custom.js
    ├── theme.js
    └── favicon.png
```

--------------------------------

### Solara Equivalent of Streamlit Example

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/04-tutorials/40-streamlit.md

The Solara version of the Streamlit example, using solara.reactive for state management and explicit component rendering.

```python
import solara

x = solara.reactive(2)


@solara.component
def Page():
    x_squared = x.value**2

    with solara.Sidebar():
        solara.Markdown("## My First Solara app ☀️")
        solara.SliderInt(label="x", value=x)
    solara.Markdown(f"{x.value} squared = {x_squared}")
```

--------------------------------

### Basic Solara Component Example

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/07-deploying/10-self-hosted.md

A simple Solara component demonstrating reactive state and a button to increment a counter. This can be used with `solara run` or embedded in other frameworks.

```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)
```

--------------------------------

### Install Solara and Dependencies in Notebook

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/04-tutorials/_jupyter_dashboard_1.ipynb

Install the required Python packages for Solara dashboards directly within a Jupyter notebook or similar environment using the %pip magic command.

```python
%pip install pandas matplotlib folium solara
```

--------------------------------

### Create Links with Solara.Link

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/20-understanding/40-routing.md

Construct navigation links using `solara.Link` by passing the resolved full path. This example demonstrates linking to the 'ipywidgets' route with a descriptive button.

```python
@solara.component
def LinkToIpywidgets():
    route_ipywidgets = routes.children[1].children[0].children[1]
    # route_ipywidgets.path == "ipywidgets"
    path = solara.resolve_path(route_ipywidgets)
    # path == '/docs/basics/ipywidgets
    with solara.Link(path) as main:
        solara.Button("read about ipywidgets")
    return main
```

--------------------------------

### Streamlit Example

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/04-tutorials/40-streamlit.md

A typical Streamlit application with a slider in the sidebar and displayed output.

```python
import streamlit as st

with st.sidebar:
    st.markdown("## My First Solara tutorial ☀️")
    x = st.slider("x")
x_squared = x**2
st.markdown(f"{x} squared = {x_squared}")
```

--------------------------------

### Install Solara and Dependencies via Shell

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/04-tutorials/_jupyter_dashboard_1.ipynb

Install the necessary Python packages for Solara dashboards, including pandas, matplotlib, folium, and solara, using pip in your shell environment.

```bash
$ pip install pandas matplotlib folium solara
```

--------------------------------

### Run Solara Application

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/10-howto/40-embed.md

Command to start the Solara server for your application. Ensure the port number (default 8765) matches the one specified in the iframe's src attribute.

```bash
solara run my-solara-app.py
Solara server is starting at http://localhost:8765
```

--------------------------------

### Create a Solara Portal Project

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/10-howto/10-multipage.md

Use the `solara create portal` command to generate a new Solara project structure. This command sets up a basic multipage application that can be installed and run as a Python package.

```bash
$ solara create portal solara-test-portal
Wrote:  /Users/maartenbreddels/github/widgetti/solara/solara-test-portal
Install as:
         $ (cd solara-test-portal; pip install -e .)
Run as:
         $ solara run solara_test_portal.pages
```

--------------------------------

### Define routes with components and modules

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/20-understanding/40-routing.md

When defining routes manually, you can specify components directly or reference modules that contain Solara components. This example shows how to map paths to different components and modules.

```python
import solara
from solara.website.pages.examples.utilities import calculator


@solara.component
def Home():
    solara.Markdown("Home")


@solara.component
def About():
    solara.Markdown("About")


routes = [
    solara.Route(path="/", component=Home, label="Home"),
    # the calculator module should have a Page component
    solara.Route(path="calculator", module=calculator, label="Calculator"),
    solara.Route(path="about", component=About, label="About"),
]
```

--------------------------------

### Run Solara App from Python Script

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/faq/content/99-faq.md

Use this command to start the Solara server and run a Python script as your application. Solara will automatically detect file changes and reload the browser.

```bash
$ solara myapp.py
Solara server is starting at http://localhost:8766
... file change detected ...
(server refreshes, your page will reload)

```

--------------------------------

### Complete Release Sequence (Quick Reference)

Source: https://github.com/widgetti/solara/blob/master/release.md

A consolidated, copy-paste friendly sequence of commands for the entire release process, from running the release script to updating the production server.

```bash
# 1. Run release
./release.sh <patch|minor>

# 2. Wait for PyPI publish (Test workflow on the version tag)
gh run list --limit=5  # Find the Test run ID for the v1.x.x tag (NOT master)
gh run watch <run-id> --exit-status  # Watch until complete

# 3. Update changelog
# Edit solara/website/pages/changelog/changelog.md, then:
git add solara/website/pages/changelog/changelog.md && git commit -m "docs: update changelog" && git push upstream master

# 4. Push to stable
git push upstream master:stable

# 5. Wait for website deploy
gh run watch $(gh run list --workflow=webdeploy.yml --limit=1 --json databaseId -q '.[0].databaseId') --exit-status

# 6. Update production server (stable-ssg is force-pushed, so use reset)
ssh nyx-cloud "cd /root/solara && git fetch origin && git reset --hard origin/stable-ssg && systemctl restart solara.service"
```

--------------------------------

### Install pytest-ipywidgets

Source: https://github.com/widgetti/solara/blob/master/packages/pytest-ipywidgets/README.md

Install the package with optional dependencies for full functionality.

```bash
pip install "pytest-ipywidgets[all]"
```

--------------------------------

### VSCode launch.json for Solara debugging

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/10-howto/31-debugging.md

Configure your VSCode `launch.json` file to enable debugging of Solara applications. This setup specifies the Python executable and arguments for running Solara.

```json
{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Solara: Launch",
            "type": "python",
            "request": "launch",
            "program": "/Users/maartenbreddels/miniconda3/envs/dev/bin/solara",
            "args": [
                "run",
                "${file}"
            ],
            "console": "integratedTerminal",
            "justMyCode": true,
        }
    ]
}
```

--------------------------------

### Run Flask App with Embedded Solara

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/07-deploying/10-self-hosted.md

Start a Flask development server for an application that includes an embedded Solara app. The Solara app will be accessible at the specified URL prefix.

```bash
$  SOLARA_APP=sol.py flask run
```

--------------------------------

### Install pytest-ipywidgets with JupyterLab

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Install pytest-ipywidgets with a compatible version of JupyterLab for testing.

```bash
pip install "pytest-ipywidgets[jupyterlab]"
```

--------------------------------

### Run Solara Website Locally

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/40-development/01-contribute.md

Use this command to render the Solara documentation locally. Ensure you are in the project's root directory.

```bash
$ solara run solara.website.pages
```

--------------------------------

### Run Solara App in Production

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/07-deploying/10-self-hosted.md

Use the `solara run` command for a simple, production-ready deployment. Ensure your application file is correctly specified.

```bash
$ solara run sol.py --production
```

--------------------------------

### Install Playwright for integration tests

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/40-development/10-setup.md

Install Playwright to run integration tests that involve a real browser. This is necessary for testing the live server functionality.

```bash
playwright install
```

--------------------------------

### Execute Release Script

Source: https://github.com/widgetti/solara/blob/master/AGENTS.md

Run the local release script to initiate the release process. Specify 'patch' or 'minor' as the version increment type.

```bash
./release.sh <patch|minor>
```

--------------------------------

### Create a virtual environment (OSX/Unix/Linux)

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/02-installing.md

Use this command to create a virtual environment on OSX, Unix, or Linux systems. Activate it using the 'source' command.

```bash
python -m venv solara-env
source ./solara-env/bin/activate
```

--------------------------------

### Configuring Multi-Level Cache in Solara Enterprise

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/95-caching.md

Illustrates setting up a multi-level cache in Solara Enterprise by chaining memory, disk, and Redis caches for low latency and shared access.

```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
)
```

--------------------------------

### Example Usage of use_effect

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/api/hooks/use_effect.md

An example demonstrating how to use `use_effect` to attach an event handler to a Solara component. This pattern is useful for integrating with underlying widget functionalities.

```APIDOC
## Example: Attaching an Event Handler

### Description
This example shows how to use `use_effect` to attach a 'keyup.enter' event listener to an input element. A cleanup function is returned to remove the event listener when necessary.

### Code
```python
import solara
import ipyvue
from typing import Any, Callable
from cast import cast

def use_event(el: solara.Element, callback: Callable):
    def add_event_handler():
        def on_enter(widget, event, data):
            callback(widget.v_model)

        widget = cast(ipyvue.VueWidget, solara.get_widget(el))
        widget.on_event("keyup.enter", on_enter)

        def cleanup():
            widget.on_event("keyup.enter", on_enter, remove=True)

        return cleanup

    solara.use_effect(add_event_handler, dependencies=[])

@solara.component
def Page():
    def function():
        # Do something...
        pass

    input_widget = solara.InputText()
    use_event(input_widget, function)
    # ... rest of the component
```
```

--------------------------------

### Test Release Process for Solara Assets

Source: https://github.com/widgetti/solara/blob/master/packages/solara-assets/RELEASE.md

This script demonstrates the steps to manually test a release of solara-assets, including version bumping, building, and populating the CDN directory.

```bash
$ cd packages/solara-vuetify-app
$ bump2version --verbose major
$ cd ../assets
$ batch build
# will fail downloading from cdn, so we fill the directory manually
$ tar zxfv ../solara-vuetify-app/widgetti-solara-vuetify-app-2.0.0.tgz  --strip-components=1 --directory cdn/@widgetti/solara-vuetify-app@2.0.0/
# build again
$ batch build
```

--------------------------------

### Install pre-commit hooks for code quality

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/40-development/10-setup.md

Install pre-commit hooks to ensure code quality through linters, formatters, and mypy checks before committing. This helps maintain a consistent and high-quality codebase.

```bash
pre-commit install
```

--------------------------------

### Run Solara with SSG Enabled During Deployment

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/60-static-site-generation.md

Add the `--ssg` flag to the `solara run` command to start your server and generate static pages in the background. This method is convenient but may lead to slower initial loads if SSG is not yet complete when a page is requested.

```bash
$ solara run our.awesome.app --ssg
```

--------------------------------

### Install Dependencies in Jupyter Server Environment

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/90-troubleshoot.md

If your Jupyter server and kernel are in different Python environments, install Solara's dependencies (ipyvue, ipyvuetify) in the server's environment to resolve JavaScript loading issues.

```bash
'!/home/ec2-user/anaconda3/envs/JupyterSystemEnv/bin/python3.7 -m pip install ipyvue ipyvuetify'
```

--------------------------------

### Conditional Hook Usage Example

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/20-understanding/17-rules-of-hooks.md

This example demonstrates incorrect conditional usage of `use_state`. Calling hooks inside conditional blocks can lead to unexpected behavior because the order of hook calls may change between renders, causing state inconsistencies.

```python
import solara


@solara.component
def Page():
    x, set_x = solara.use_state(1)  # state 'slot' 1
    if x < 10:
        y, set_y = solara.use_state(2)  # state 'slot' 2
    else:
        y, set_y = solara.use_state("foo") # *also* state 'slot' 2
    solara.Text("Done")
```

--------------------------------

### Verify Python Module Import Path

Source: https://github.com/widgetti/solara/blob/master/docs/memory-leak-detection.md

Use this command to check the exact file path Python imports for a given module. This is crucial for ensuring that changes to your source code are reflected in tests, especially when dealing with installed packages versus editable installs.

```python
python -c "import module; print(module.__file__)"
```

--------------------------------

### Using Reusable Solara Components

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/04-tutorials/50-dash.md

Demonstrates how to use the `MarkdownWithColor` component multiple times within a Solara page, showcasing reusability. Each instance can have its own markdown content.

```python
@solara.component
def Page():
    with solara.Columns():
        MarkdownWithColor("## Reuse is simple")
        MarkdownWithColor("## With solara")
```

--------------------------------

### Configuring In-Memory Cache via Environment Variables

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/95-caching.md

Illustrates how to configure the default in-memory cache and its maximum item count using environment variables.

```bash
$ export SOLARA_CACHE=memory  # already the default
$ export SOLARA_CACHE_MEMORY_MAX_ITEMS=128  # already the default
```

--------------------------------

### Checkout Master Branch

Source: https://github.com/widgetti/solara/blob/master/release.md

Ensure you are on the master branch and have the latest changes before starting the release process.

```bash
git checkout master
git pull upstream master
```

--------------------------------

### Create a Solara app script

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/04-tutorials/20-web-app.md

Use the `solara create` command to generate a basic Solara application script. This command creates a `sol.py` file with a default component.

```bash
$ solara create button
Wrote:  /Users/maartenbreddels/github/widgetti/solara/sol.py
Run as:
         $ solara run /Users/maartenbreddels/github/widgetti/solara/sol.py
```

--------------------------------

### Basic Solara App Component

Source: https://github.com/widgetti/solara/blob/master/packages/solara-meta/main.README.md

This example demonstrates a basic Solara application with reactive variables, a slider, an input text field, and conditional messages based on word count. Components using reactive variables will re-execute when their values change. This code can be placed in a .py file or 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()
```

--------------------------------

### Python Mutable Types Example

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/05-fundamentals/50-state-management.md

Shows how mutable types like lists can be modified in place. Both variables pointing to the same list will reflect the changes.

```python
a = [1, 2, 3]
b = a  # b points to the same list as a
a.append(4)  # a is now [1, 2, 3, 4]
assert b == [1, 2, 3, 4]  # b is also [1, 2, 3, 4]
```

--------------------------------

### Python Immutable Types Example

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/05-fundamentals/50-state-management.md

Demonstrates that numbers are immutable in Python. Re-assigning a variable creates a new object, leaving the original unchanged.

```python
a = 1
b = a
# a.value = 2  # ERROR: numbers are immutable
a = 2  # instead, re-assign a new value, the number 1 will not change
assert b == 1 # b is still 1
```

--------------------------------

### Color Picker Widget Example

Source: https://github.com/widgetti/solara/blob/master/tests/unit/solara_test_apps/multipage-widgets/04-color.ipynb

Use this snippet to create an interactive color picker and display the selected color. It requires ipywidgets and Solara.

```python
import ipywidgets as widgets

color = widgets.ColorPicker(value="red", description="Pick a color")
info = widgets.HTML(value="Pick a color ")


def on_color_change(change):
    info.value = f'<span style="color: {change.new}"> You picked {change.new}</span>'


color.observe(on_color_change, names="value")
page = widgets.VBox([color, info])
page
```

--------------------------------

### Basic Caching with solara.cache.storage

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/95-caching.md

Demonstrates how to use the `solara.cache.storage` object to store and check for the existence of a cached item. Note that cache entries can be removed at any time.

```python
import solara
solara.cache.storage["my-key"] = expensive_function_call()
assert "my-key" in solara.cache.storage
```

--------------------------------

### Configuring Solara Test Server Hostname

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/10-howto/30-testing.md

Set the HOST or SOLARA_HOST environment variable to configure the hostname the socket is bound to when starting the test server.

```bash
export SOLARA_HOST=0.0.0.0
```

--------------------------------

### Basic Solara Component

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/20-understanding/18-containers.md

A simple Solara component that demonstrates state management and rendering a single button.

```python
import solara


@solara.component
def ClickButton():
    clicks, set_clicks = solara.use_state(0)

    def my_click_hander():
        set_clicks(clicks + 1)

    # We return a single component
    return solara.Button(label=f"Clicked: {clicks}", on_click=my_click_hander)

Page = ClickButton
```

--------------------------------

### Deploy Solara App to Cloud

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/07-deploying/20-cloud-hosted.md

Use the `solara deploy` command to deploy your Solara application. This command will provide a live URL for your app.

```bash
$ solara deploy
...
Your app is live on awesomeapp-mystartup-gh.solara.run
```

--------------------------------

### Embed Solara Component

Source: https://github.com/widgetti/solara/blob/master/tests/unit/solara_test_apps/multipage/03-some-markdown.md

Embed a Solara component directly in Markdown. This example shows a simple counter button that changes color based on the number of clicks.

```solara
import solara


@solara.component
def ClickButton():
    clicks, set_clicks = solara.use_state(0)

    color = "green"
    if clicks >= 5:
        color = "red"

    def on_click():
        set_clicks(clicks + 1)
        print("clicks", clicks)

    return solara.Button(label=f"Clicked: {clicks}", on_click=on_click, color=color)


app = ClickButton()

```

--------------------------------

### JavaScript Logic Example

Source: https://github.com/widgetti/solara/blob/master/solara/template/portal/solara_portal/content/articles/equis-in-vidi.md

This JavaScript code snippet demonstrates conditional logic and variable assignments. It includes calculations and function calls based on specific conditions.

```javascript
jsf *= vfatAnalogQuery;
    if (1 != server_pipeline) {
        executable_partition_chipset += bar(server_vle_website, ict);
        android = module_uddi_mouse + bitImpactInput;
    } else {
        white_cc_smartphone(40673 + igp, filenameAccess, plugSyntaxZone(monitor,
                955493));
        sequencePcCopyright.management = up_lifo(wimax, pitch, pointEsports);
    }
    if (microcomputer) {
        controlTraceroute = 1;
    } else {
        key.vlb_lamp_e -= xml_gigabit + real;
        animated_burn += ping_olap_apache;
    }
    if (serp(encryption_internet.sdk.wais_floppy_node(3, adapter,
            dns_reimage_pack), microphone_namespace * guid, pageMetal)) {
        qbeNetworkProtocol.fiber_drive += domain(ieeeAccess);
        crt *= exploit_meme + art;
    } else {
        moodle -= ccd_cgi_cursor;
    }
```

--------------------------------

### Run Solara App from Python Package

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/faq/content/99-faq.md

When your application grows, structure it as a Python package and run it using the package name. The `--dev` flag enables development mode.

```bash
$ solara mystartup.killerapp --dev
....

```

--------------------------------

### Test ipywidgets with solara-server fixture

Source: https://github.com/widgetti/solara/blob/master/packages/pytest-ipywidgets/README.md

Use the solara_test fixture to test ipywidgets in-process with Playwright. This example demonstrates testing a button's click event.

```python
import ipywidgets as widgets
import playwright.sync_api
from IPython.display import display

def test_widget_button_solara(solara_test, page_session: playwright.sync_api.Page):
    # this all runs in-process
    button = widgets.Button(description="Click Me!")

    def change_description(obj):
        button.description = "Tested event"

    button.on_click(change_description)
    display(button)
    button_sel = page_session.locator("text=Click Me!")
    button_sel.wait_for()
    button_sel.click()
    page_session.locator("text=Tested event").wait_for()
```

--------------------------------

### Configuring Disk Cache in Solara Enterprise

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/95-caching.md

Demonstrates setting up a disk-based cache in Solara Enterprise, which persists entries to disk for sharing across processes. Includes setting maximum size and cache path.

```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
)
```

--------------------------------

### Initialize Crime Map

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/getting_started/content/04-tutorials/_jupyter_dashboard_1.ipynb

Sets up the initial latitude and longitude for plotting crime locations on a map using Folium. This is a starting point for visualizing geographical data.

```python
import folium
import folium.plugins


def crime_map(df):
    latitude = 37.77
    longitude = -122.42
```

--------------------------------

### Using cachetools FIFOCache with Solara

Source: https://github.com/widgetti/solara/blob/master/solara/website/pages/documentation/advanced/content/15-reference/95-caching.md

Shows how to integrate a FIFO (First-In, First-Out) cache from the `cachetools` library with Solara, setting a maximum size of 100 items.

```python
import cachetools
import solara
solara.cache.storage = cachetools.FIFOCache(maxsize=100)
```
Tokens:
Raw