solara-ui 1.45.0__py3-none-any.whl

solara/website/pages/documentation/api/utilities/on_kernel_start.py

@@ -0,0 +1,44 @@
+"""
+# on_kernel_start
+
+Run a function when a virtual kernel (re)starts and optionally run a cleanup function on shutdown.
+
+```python
+def on_kernel_start(f: Callable[[], Optional[Callable[[], None]]]) -> Callable[[], None]:
+    ...
+```
+
+`f` will be called on each virtual kernel (re)start. This (usually) happens each time a browser tab connects to the server
+[see solara server for more details](https://solara.dev/docs/understanding/solara-server).
+The (optional) function returned by `f` will be called on kernel shutdown.
+
+Note that the cleanup functions are called in reverse order with respect to the order in which they were registered
+(e.g. the cleanup function of the last call to `on_kernel_start` will be called first on kernel shutdown).
+
+The return value of on_kernel_start is a cleanup function that will remove the callback from the list of callbacks to be called on kernel start.
+
+During hot reload, the callbacks that are added from scripts or modules that will be reloaded will be removed before the app is loaded
+again. This can cause the order of the callbacks to be different than at first run.
+
+## Example
+
+```
+import solara
+import solara.lab
+
+
+@solara.lab.on_kernel_start
+def on_kernel_start():
+    id = solara.get_kernel_id()
+    print("Kernel started", id)
+    def cleanup():
+        print("Kernel stopped", id)
+    return cleanup  # this function will be called on kernel shutdown
+```
+
+"""
+
+from solara.website.components import NoPage
+
+title = "on_kernel_start"
+Page = NoPage

solara/website/pages/documentation/api/utilities/reactive.py

@@ -0,0 +1,16 @@
+"""
+# reactive
+
+"""
+
+import solara
+from solara.website.components import NoPage
+from solara.website.utils import apidoc
+
+title = "reactive"
+
+
+Page = NoPage
+
+
+__doc__ += apidoc(solara.reactive)  # type: ignore

solara/website/pages/documentation/api/utilities/widget.py

@@ -0,0 +1,104 @@
+"""
+
+# Component.widget
+
+Create a classic ipywidget from a component.
+
+```python
+def widget(self, **kwargs):
+    ...
+```
+
+
+This will create a widget from the component. The widget will be a
+subclass of `ipywidgets.VBox` and `ipywidgets.ValueWidget`.
+
+Example
+
+```python
+import solara
+widget = solara.FileDownload.widget(data="some text data", filename="solara-demo.txt")
+```
+
+This is very useful if you are migrating your application from a classic
+ipywidget to solara. See [also the ipywidgets tutorial](/documentation/getting_started/tutorials/ipywidgets).
+
+The `ipywidgets.ValueWidget` is used to enable the use of the widget in
+interact, or interactive. The `ipywidgets.VBox` is used to enable
+nesting of widgets.
+
+All keyword arguments will be passed to the component.
+Each argument pair of `on_<name>` and `<name>` will
+be added as a trait in the widget.
+
+For example,
+
+```solara
+import solara
+import ipywidgets as widgets
+import random
+
+
+countries_demo_data = {
+    "Netherlands": ["Amsterdam", "Rotterdam", "The Hague"],
+    "Germany": ["Berlin", "Hamburg", "Munich"],
+    "France": ["Paris", "Marseille", "Lyon"],
+}
+
+
+# this component can be used in a component three, but ...
+@solara.component
+def LocationSelect(value, on_value, countries=countries_demo_data):
+    country, city = value
+    cities = countries.get(country, [])
+    # reset to None if not in the list of countries
+    if city not in cities:
+        city = None
+        # update the state if we changed/reset city
+        on_value((country, city))
+
+    with solara.Card("Location"):
+        solara.Select(label="country",
+                      values=list(countries),
+                      value=country,
+                      on_value=lambda country: on_value((country, city)),
+        )
+        solara.Select(label="city",
+                      values=cities,
+                      value=city,
+                      on_value=lambda city: on_value((country, city)),
+        )
+
+
+# Using .widget(...) we can create a widget from it.
+# For use with interact:
+@widgets.interact(location=LocationSelect.widget(value=("Netherlands", "Amsterdam")))
+def f(size=3.4, location=None):
+    print(size, location)
+
+
+# Or to add to your VBox:
+widgets.VBox(
+    [LocationSelect.widget(value=("Netherlands", "Amsterdam"))]
+)
+
+# this is how you'd use it as a component
+@solara.component
+def Page():
+    value, set_value = solara.use_state(("Netherlands", "Amsterdam"))
+    def pick():
+        country = random.choice(list(countries_demo_data))
+        city = random.choice(countries_demo_data[country])
+        set_value((country, city))
+
+    LocationSelect(value=value, on_value=set_value)
+    solara.Button("Pick random place", on_click=pick)
+
+```
+
+"""
+
+from solara.website.components import NoPage
+
+Page = NoPage
+title = "widget"

solara/website/pages/documentation/components/__init__.py

@@ -0,0 +1,12 @@
+import solara
+from solara.website.components import CategoryLayout, Gallery
+
+
+@solara.component
+def Page(route_external=None):
+    Gallery(route_external)
+
+
+@solara.component
+def Layout(children=[]):
+    CategoryLayout(children=children)

solara/website/pages/documentation/components/advanced/__init__.py

@@ -0,0 +1,9 @@
+import solara
+from solara.website.components import NoPage, SubCategoryLayout
+
+Page = NoPage
+
+
+@solara.component
+def Layout(children=[]):
+    SubCategoryLayout(children=children)

solara/website/pages/documentation/components/advanced/link.py

@@ -0,0 +1,25 @@
+"""# Link"""
+
+import solara
+from solara.website.utils import apidoc
+
+routes = [
+    solara.Route(path="/"),
+    solara.Route(path="kiwi"),
+    solara.Route(path="banana"),
+    solara.Route(path="apple"),
+]
+
+
+@solara.component
+def Page():
+    route_current, routes = solara.use_route()
+    solara.Info("Note the address bar in the browser. It should change to the path of the link.")
+    with solara.Row():
+        for route in routes:
+            with solara.Link(route):
+                current = route_current is route
+                solara.Button(f"Go to {route.path}", color="red" if current else None)
+
+
+__doc__ += apidoc(solara.Link.f)  # type: ignore

solara/website/pages/documentation/components/advanced/meta.py

@@ -0,0 +1,17 @@
+"""# Meta"""
+
+import solara
+from solara.website.utils import apidoc
+
+
+@solara.component
+def Page():
+    solara.Info("Nothing to see here, only in this page's source code, or by looking at the google search results for this page.")
+    with solara.Head():
+        solara.Meta(
+            name="description",
+            content="The Meta component can be used to set the description of a page. This is useful for SEO, or crawlers that index your page.",
+        )
+
+
+__doc__ += apidoc(solara.Meta.f)  # type: ignore

solara/website/pages/documentation/components/advanced/style.py

@@ -0,0 +1,43 @@
+"""
+# Style
+
+"""
+
+import solara
+from solara.website.utils import apidoc
+
+
+@solara.component
+def Page():
+    insert_css, set_insert_css = solara.use_state(True)
+
+    css = """
+    .mybutton {
+        font-family: Serif;
+    }
+
+    /* this selector has to be very specific to override the vuetify style */
+    .v-btn.mybutton {
+        color: #4CAF50; /* Green */
+    }
+    /* vuetify's background color css has very high CSS-specificity, so we use !important */
+    .mybutton {
+        background-color: #FF9800 !important; /* Orange */
+    }
+    """
+
+    solara.Checkbox(label="Use CSS", value=insert_css, on_value=set_insert_css)
+    solara.Markdown(
+        f"""
+## CSS Example that styles the button below
+```css
+{css}
+```
+"""
+    )
+    if insert_css:
+        solara.Style(css)
+    solara.Button(label="Advanced users might want to style this", icon_name="mdi-thumb-up", classes=["mybutton"])
+
+
+__doc__ += apidoc(solara.Style.f)  # type: ignore

solara/website/pages/documentation/components/common.py

@@ -0,0 +1,9 @@
+import solara
+from solara.alias import rv
+
+
+@solara.component
+def ColorCard(title, color):
+    with rv.Card(style_=f"background-color: {color}; width: 100%; height: 100%") as main:
+        rv.CardTitle(children=[title])
+    return main

solara/website/pages/documentation/components/data/__init__.py

@@ -0,0 +1,9 @@
+import solara
+from solara.website.components import NoPage, SubCategoryLayout
+
+Page = NoPage
+
+
+@solara.component
+def Layout(children=[]):
+    SubCategoryLayout(children=children)

solara/website/pages/documentation/components/data/dataframe.py

@@ -0,0 +1,44 @@
+"""
+# DataFrame
+
+"""
+
+from typing import Any, Dict, Optional, cast
+
+import plotly
+
+import solara
+from solara.website.utils import apidoc
+
+df = plotly.data.iris()
+
+
+@solara.component
+def Page():
+    column, set_column = solara.use_state(cast(Optional[str], None))
+    cell, set_cell = solara.use_state(cast(Dict[str, Any], {}))
+
+    def on_action_column(column):
+        set_column(column)
+
+    def on_action_cell(column, row_index):
+        set_cell(dict(column=column, row_index=row_index))
+
+    column_actions = [solara.ColumnAction(icon="mdi-sunglasses", name="User column action", on_click=on_action_column)]
+    cell_actions = [solara.CellAction(icon="mdi-white-balance-sunny", name="User cell action", on_click=on_action_cell)]
+    solara.Markdown(
+        f"""
+        ## Demo
+
+        Below we show display the titanic dataset, and demonstrate a user column and cell action. Try clicking on the triple icon when hovering
+        above a column or cell. And see the following values changes:
+
+        * Column action on: `{column}`
+        * Cell action on: `{cell}`
+
+    """
+    )
+    solara.DataFrame(df, column_actions=column_actions, cell_actions=cell_actions)
+
+
+__doc__ += apidoc(solara.DataFrame.f)  # type: ignore

solara/website/pages/documentation/components/data/pivot_table.py

@@ -0,0 +1,81 @@
+"""
+# PivotTable
+
+Interactive [Pivot Table](https://en.wikipedia.org/wiki/Pivot_table) showing aggregated data in groups.
+
+We provide three version of the pivot table
+
+    * PivotTableView: Takes already aggregated data as input
+    * PivotTable: Takes a dataframe as input and aggregates it for you.
+    * PivotTableCard: Similar to PivotTable but with a card layout, and configuration options.
+
+"""
+
+import solara
+
+try:
+    import vaex.datasets
+
+    df = vaex.datasets.titanic()
+except Exception:
+    df = None
+    vaex = None
+
+
+@solara.component
+def View():
+    # select on the 2nd x axis, index=3, which means (pclass=2, survived=true)
+    # Note: the indices refer to the header_x and header_y
+    selected, on_selected = solara.use_state({"x": [1, 3]})
+    data = solara.PivotTableData(
+        {
+            "x": ["pclass", "survived"],
+            "y": ["sex"],
+            "agg": "count",
+            "values": [["5", "118"], ["139", "61"], ["12", "146"], ["94", "25"], ["110", "418"], ["106", "75"]],
+            "values_x": ["123", "200", "158", "119", "528", "181"],
+            "values_y": ["466", "843"],
+            "headers_x": [["1", "1", "2", "2", "3", "3"], ["false", "true", "false", "true", "false", "true"]],
+            "headers_y": [["female", "male"]],
+            "counts_x": 6,
+            "counts_y": 2,
+            "total": "1,309",
+        }
+    )
+    with solara.VBox() as main:
+        solara.Markdown(f"`selected = {selected}`")
+        solara.PivotTableView(data=data, selected=selected, on_selected=on_selected)
+    return main
+
+
+@solara.component
+def Page():
+    if vaex is None:
+        return solara.Markdown("This example requires vaex, please install it with `pip install vaex`")
+    with solara.Div() as main:
+        solara.Markdown("# Titanic")
+        selected, on_selected = solara.use_state({"x": [0, 0]})  # noqa: SH101
+        solara.provide_cross_filter()
+        with solara.VBox():
+            type, set_type = solara.use_state("view")  # noqa: SH101
+            with solara.ToggleButtonsSingle(type, on_value=set_type):
+                solara.Button("PivotTableView", value="view")
+                solara.Button("PivotTable", value="df")
+                solara.Button("PivotTableCard", value="card")
+            if type == "view":
+                solara.Markdown("# PivotTableView\nThis component will take aggregates data as input")
+                View()
+            elif type == "df":
+                solara.Markdown("# PivotTable\nThis component aggregates the dataframe for you")
+                solara.Markdown(f"`selected = {selected}`")
+                solara.PivotTable(df, ["pclass"], ["sex"], selected=selected, on_selected=on_selected)
+            elif type == "card":
+                solara.Markdown("# PivotTable\nThis component aggregates the dataframe for you, and gives a UI to configure the component")
+                solara.Markdown(f"`selected = {selected}`")
+                solara.PivotTableCard(df, ["pclass"], ["sex"], selected=selected, on_selected=on_selected)
+    return main
+
+
+Component = Page
+App = Component
+app = Page()

solara/website/pages/documentation/components/enterprise/__init__.py

@@ -0,0 +1,9 @@
+import solara
+from solara.website.components import NoPage, SubCategoryLayout
+
+Page = NoPage
+
+
+@solara.component
+def Layout(children=[]):
+    SubCategoryLayout(children=children)

solara/website/pages/documentation/components/enterprise/avatar.py

@@ -0,0 +1,24 @@
+"""
+# Avatar
+
+"""
+
+from types import ModuleType
+from typing import Optional
+
+auth: Optional[ModuleType]
+try:
+    from solara_enterprise import auth
+except ImportError:
+    auth = None
+from solara.website.components import NoPage
+from solara.website.utils import apidoc
+
+title = "Avatar"
+
+Page = NoPage
+
+if auth:
+    __doc__ += apidoc(auth.Avatar.f)  # type: ignore
+else:
+    __doc__ += "solara-enterprise not installed."

solara/website/pages/documentation/components/enterprise/avatar_menu.py

@@ -0,0 +1,25 @@
+"""
+# AvatarMenu
+
+"""
+
+from types import ModuleType
+from typing import Optional
+
+auth: Optional[ModuleType]
+try:
+    from solara_enterprise import auth
+except ImportError:
+    auth = None
+from solara.website.components import NoPage
+from solara.website.utils import apidoc
+
+title = "AvatarMenu"
+
+Page = NoPage
+
+
+if auth:
+    __doc__ += apidoc(auth.AvatarMenu.f)  # type: ignore
+else:
+    __doc__ += "solara-enterprise not installed."

solara/website/pages/documentation/components/input/__init__.py

@@ -0,0 +1,9 @@
+import solara
+from solara.website.components import NoPage, SubCategoryLayout
+
+Page = NoPage
+
+
+@solara.component
+def Layout(children=[]):
+    SubCategoryLayout(children=children)

solara/website/pages/documentation/components/input/button.py

@@ -0,0 +1,23 @@
+"""
+# Button
+
+"""
+
+import solara
+from solara.website.utils import apidoc
+
+
+@solara.component
+def Page():
+    count, set_count = solara.use_state(0)
+
+    def increment():
+        set_count(count + 1)
+
+    with solara.VBox() as main:
+        with solara.HBox():
+            solara.Button(label=f"Clicked {count} times", on_click=increment, icon_name="mdi-thumb-up")
+    return main
+
+
+__doc__ += apidoc(solara.Button.f)  # type: ignore

solara/website/pages/documentation/components/input/checkbox.py

@@ -0,0 +1,10 @@
+"""# Checkbox"""
+
+import solara
+from solara.website.components import NoPage
+from solara.website.utils import apidoc
+
+Page = NoPage
+
+
+__doc__ += apidoc(solara.Checkbox.f)  # type: ignore

solara/website/pages/documentation/components/input/file_browser.py

@@ -0,0 +1,30 @@
+"""# FileBrowser"""
+
+from pathlib import Path
+from typing import Optional, cast
+
+import solara
+from solara.website.utils import apidoc
+
+
+@solara.component
+def Page():
+    file, set_file = solara.use_state(cast(Optional[Path], None))
+    path, set_path = solara.use_state(cast(Optional[Path], None))
+    directory, set_directory = solara.use_state(Path("~").expanduser())
+
+    can_select = solara.ui_checkbox("Enable select")
+
+    def reset_path():
+        set_path(None)
+        set_file(None)
+
+    # reset path and file when can_select changes
+    solara.use_memo(reset_path, [can_select])
+    solara.FileBrowser(directory, on_directory_change=set_directory, on_path_select=set_path, on_file_open=set_file, can_select=can_select)
+    solara.Info(f"You are in directory: {directory}")
+    solara.Info(f"You selected path: {path}")
+    solara.Info(f"You opened file: {file}")
+
+
+__doc__ += apidoc(solara.FileBrowser.f)  # type: ignore

solara/website/pages/documentation/components/input/file_drop.py

@@ -0,0 +1,76 @@
+"""
+# FileDrop components
+
+FileDrop comes in two flavours:
+
+   * `FileDrop` for a single file upload
+   * `FileDropMultiple` which allows for multiple file upload
+
+
+"""
+
+import textwrap
+from typing import List, cast
+
+import solara
+from solara.components.file_drop import FileInfo
+from solara.website.utils import apidoc
+
+
+@solara.component
+def FileDropMultipleDemo():
+    content, set_content = solara.use_state(cast(List[bytes], []))
+    filename, set_filename = solara.use_state(cast(List[str], []))
+    size, set_size = solara.use_state(cast(List[int], []))
+
+    def on_file(files: List[FileInfo]):
+        set_filename([f["name"] for f in files])
+        set_size([f["size"] for f in files])
+        set_content([f["file_obj"].read(100) for f in files])
+
+    solara.FileDropMultiple(
+        label="Drag and drop files(s) here to read the first 100 bytes.",
+        on_file=on_file,
+        lazy=True,  # We will only read the first 100 bytes
+    )
+    if content:
+        solara.Info(f"Number of uploaded files: {len(filename)}")
+        for f, s, c in zip(filename, size, content):
+            solara.Info(f"File {f} has total length: {s}\n, first 100 bytes:")
+            solara.Preformatted("\n".join(textwrap.wrap(repr(c))))
+
+
+@solara.component
+def FileDropDemo():
+    content, set_content = solara.use_state(b"")
+    filename, set_filename = solara.use_state("")
+    size, set_size = solara.use_state(0)
+
+    def on_file(f: FileInfo):
+        set_filename(f["name"])
+        set_size(f["size"])
+        set_content(f["file_obj"].read(100))
+
+    solara.FileDrop(
+        label="Drag and drop a file here to read the first 100 bytes.",
+        on_file=on_file,
+        lazy=True,  # We will only read the first 100 bytes
+    )
+    if content:
+        solara.Info(f"File {filename} has total length: {size}\n, first 100 bytes:")
+        solara.Preformatted("\n".join(textwrap.wrap(repr(content))))
+
+
+@solara.component
+def Page():
+    with solara.Row():
+        with solara.Card(title="FileDrop"):
+            FileDropDemo()
+        with solara.Card(title="FileDropMultiple"):
+            FileDropMultipleDemo()
+
+
+__doc__ += "# FileDrop"
+__doc__ += apidoc(solara.FileDrop.f)  # type: ignore
+__doc__ += "# FileDropMultiple"
+__doc__ += apidoc(solara.FileDropMultiple.f)  # type: ignore

solara/website/pages/documentation/components/input/input.py

@@ -0,0 +1,43 @@
+"""# Input fields
+
+This page contains all the input fields available in Solara.
+
+# InputText
+"""
+
+import solara
+from solara.website.components import NoPage
+from solara.website.utils import apidoc
+
+Page = NoPage
+
+
+__doc__ += apidoc(solara.InputText.f)  # type: ignore
+__doc__ += "# InputTextArea"
+__doc__ += apidoc(solara.InputTextArea.f)  # type: ignore
+__doc__ += "# InputFloat"
+__doc__ += apidoc(solara.InputFloat.f)  # type: ignore
+__doc__ += "# InputInt"
+__doc__ += apidoc(solara.InputInt.f)  # type: ignore
+
+__doc__ += """
+# Autofocus Example
+
+```solara
+import solara
+import solara.lab
+
+
+@solara.component
+def Page():
+    show_dialog = solara.use_reactive(False)
+    show_conditional = solara.use_reactive(False)
+    with solara.Row():
+        solara.Button("Show dialog", on_click=lambda: show_dialog.set(True))
+        solara.Button("Show conditionally rendered element", on_click=lambda: show_conditional.set(not show_conditional.value))
+    with solara.lab.ConfirmationDialog(open=show_dialog):
+        solara.InputFloat("Float here", autofocus=True)
+    if show_conditional.value:
+        solara.InputFloat("Float here", autofocus=True)
+```
+"""