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

solara/components/misc.py

@@ -1,333 +0,0 @@
-import warnings
-from typing import Any, Callable, Dict, List, Union
-
-import reacton
-import reacton.ipyvuetify as v
-import solara
-import solara.widgets
-from solara.util import _combine_classes
-
-Navigator = reacton.core.ComponentWidget(solara.widgets.Navigator)
-GridDraggable = reacton.core.ComponentWidget(solara.widgets.GridLayout)
-# keep the old name for a while
-GridLayout = GridDraggable
-
-
-@solara.component
-def ListItem(title, icon_name: str = None, children=[], value=None):
-    if value is None:
-        value = title
-    if children:
-        with v.ListItemContent() as main:
-            v.ListItemTitle(children=[title])
-            if icon_name is not None:
-                with v.ListItemIcon():
-                    v.Icon(children=[icon_name or ""])
-        return v.ListGroup(children=children, v_slots=[{"name": "activator", "children": main}], no_action=True, value=True, append_icon=icon_name)
-    else:
-        with v.ListItem(value=value) as main:
-            if icon_name is not None:
-                with v.ListItemIcon():
-                    v.Icon(children=[icon_name or ""])
-            with v.ListItemContent():
-                v.ListItemTitle(children=[title])
-        return main
-
-
-def ui_dropdown(label, value=None, options=["foo", "bar"], key=None, disabled=False, **kwargs):
-    key = key or str(value) + str(label) + str(options)
-    value, set_value = solara.use_state(value, key)
-
-    def set_index(index):
-        set_value(options[index])
-
-    v.Select(v_model=value, label=label, items=options, on_v_model=set_value, clearable=True, disabled=disabled, **kwargs)
-    return value
-
-
-def ui_text(label, value="", key=None, clearable=False, hint="", disabled=False, **kwargs):
-    key = key or str(value) + str(label) + str(hint)
-    value, set_value = solara.use_state(value, key)
-    v.TextField(v_model=value, label=label, on_v_model=set_value, clearable=clearable, hint=hint, disabled=disabled, **kwargs)
-    return value
-
-
-def ui_checkbox(label, value=True, key=None, disabled=False, **kwargs):
-    key = key or str(value) + str(label)
-    value, set_value = solara.use_state(value, key)
-    v.Checkbox(v_model=value, label=label, on_v_model=set_value, **kwargs)
-    return value
-
-
-def ui_slider(value=1, label="", min=0, max=100, key=None, tick_labels=None, thumb_label=None, disabled=False, **kwargs):
-    key = key or str(value) + str(label)
-    value, set_value = solara.use_state(value, key)
-    v.Slider(
-        v_model=value,
-        label=label,
-        min=min,
-        max=max,
-        on_v_model=set_value,
-        ticks=tick_labels is not None,
-        tick_labels=tick_labels,
-        thumb_label=thumb_label,
-        disabled=disabled,
-        **kwargs,
-    )
-    return value
-
-
-@solara.component
-def Text(text, style: Union[str, Dict[str, str], None] = None, classes: List[str] = []):
-    style_flat = solara.util._flatten_style(style)
-    return v.Html(tag="span", class_=_combine_classes(classes), style_=style_flat, children=[text])
-
-
-@solara.component
-def Div(children=[], classes: List[str] = [], style: Union[str, Dict[str, str], None] = None, **kwargs):
-    style_flat = solara.util._flatten_style(style)
-    classes = classes.copy()
-    kwargs = kwargs.copy()
-    if "class_" in kwargs:
-        classes.append(kwargs.pop("class_"))
-    if "style_" in kwargs:
-        style_flat += kwargs.pop("style_")
-    class_ = _combine_classes(classes)
-
-    return v.Html(tag="div", children=children, class_=class_, style_=style_flat, **kwargs)
-
-
-@solara.component
-def Preformatted(text, **kwargs):
-    return v.Html(tag="pre", children=[text], **kwargs)
-
-
-@solara.component
-def IconButton(icon_name: str = None, on_click=Callable[[], None], children: list = [], click_event="click", **kwargs):
-    return solara.Button(icon_name=icon_name, on_click=on_click, children=children, icon=True, click_event=click_event, **kwargs)
-
-
-@solara.component
-def HTML(tag="div", unsafe_innerHTML=None, style: str = None, classes: List[str] = [], attributes=None, class_: str = None):
-    """Render an HTML tag with optional raw HTML text inside.
-
-    # Arguments
-
-     * `tag`: HTML tag name for the top level element (default: `div`)
-     * `unsafe_innerHTML`: HTML string to be rendered inside the tag.
-        Note that this is not sanitized, so be careful this cannot include JavaScript from user input!
-     * `style`: CSS style string to be applied to the top level element.
-     * `classes`: List of CSS classes to be applied to the top level element.
-     * `attributes`: Dictionary of attributes to be applied to the top level element.
-     * `class_`: (deprecated) CSS class to be applied to the top level element.
-
-    """
-    if attributes is None:
-        attributes = {}
-    else:
-        attributes = attributes.copy()
-    if style:
-        attributes["style"] = style
-    if class_ or classes:
-        class_ = _combine_classes([*classes, *([] if class_ is None else [class_])])
-        attributes["class"] = class_
-    return solara.widgets.HTML.element(tag=tag, unsafe_innerHTML=unsafe_innerHTML, attributes=attributes)
-
-
-@solara.component
-def VBox(children=[], grow=True, align_items="stretch", classes: List[str] = []):
-    """Deprecated. Use `Row` instead."""
-    style = f"flex-direction: column; align-items: {align_items};"
-    if grow:
-        style += "flex-grow: 1;"
-    class_ = _combine_classes(["d-flex", *classes])
-    return v.Sheet(class_=class_, style_=style, elevation=0, children=children)
-
-
-@solara.component
-def HBox(children=[], grow=True, align_items="stretch", classes: List[str] = []):
-    """Deprecated. Use `Column` instead."""
-    style = f"flex-direction: row; align-items: {align_items}; "
-    if grow:
-        style += "flex-grow: 1;"
-    class_ = _combine_classes(["d-flex", *classes])
-    return v.Sheet(class_=class_, style_=style, elevation=0, children=children)
-
-
-@solara.component
-def Row(children=[], gap="12px", justify="start", margin: int = 0, classes: List[str] = [], style: Union[str, Dict[str, str], None] = None):
-    """Lays out children in a row, side by side, with the given gap between them.
-
-    See also [Column](/documentation/components/layout/column).
-
-    Example with three children side by side:
-
-    ```solara
-    import solara
-
-    @solara.component
-    def Page():
-        with solara.Row(gap="10px", justify="space-around"):
-            solara.Text("On the left")
-            solara.Text("In the middle")
-            solara.Text("On the right")
-    ```
-    ## Arguments
-
-     * `children`: List of children to render in the column.
-     * `gap`: The gap between each child, as a CSS string.
-     * `justify`: How children are distributed along the x/horizontal-axis, can be "start" (default), "center", "end", "space-around",
-        "space-between" or "space-evenly".
-        (*Note: this translates to justify-content in CSS*).
-     * `margin`: The margin around the column, translate to 4*margin pixels.
-     * `classes`: List of CSS classes to apply to the column.
-     * `style`: CSS style to apply to the column.
-
-    """
-    align_items = "stretch"
-    style_flat = solara.util._flatten_style(style)
-    style_flat = f"flex-direction: row; align-items: {align_items}; justify-content: {justify}; column-gap: {gap};" + style_flat + ";"
-    # valid css values, but we don't list them as options to avoid confusion
-    extra_justify_options = ["left", "right", "flex-start", "flex-end"]
-    if justify not in (["start", "center", "end", "space-around", "space-between", "space-evenly"] + extra_justify_options):
-        warnings.warn(f"Invalid value for justify: {justify}, possible values are: start, center, end, space-around, space-between, space-evenly")
-    class_ = _combine_classes(["d-flex", f"ma-{margin}", *classes])
-    return v.Sheet(class_=class_, style_=style_flat, elevation=0, children=children)
-
-
-@solara.component
-def Column(children=[], gap="12px", align="stretch", margin: int = 0, classes: List[str] = [], style: Union[str, Dict[str, str], None] = None):
-    """Lays out children in a column on top of each other, with the given gap between them.
-
-    See also [Row](/documentation/components/layout/row).
-
-    Example with three children on top of each other:
-
-    ```solara
-    import solara
-
-    @solara.component
-    def Page():
-        with solara.Column(gap="10px"):
-            solara.Text("On top")
-            solara.Text("In the middle")
-            solara.Text("On bottom")
-    ```
-
-    ## Arguments
-
-     * `children`: List of children to render in the column.
-     * `gap`: The gap between each child, as a CSS string.
-     * `align`: The alignment of the children, can be "start", "center", "end", "stretch" (default).
-        (*Note: this translates to align-items in CSS*).
-     * `margin`: The margin around the column, translate to 4*margin pixels.
-     * `classes`: List of CSS classes to apply to the column.
-     * `style`: CSS style to apply to the column.
-
-    """
-    if align == "left":
-        warnings.warn("align='left' does not exists, you probably want align='start' instead")
-        align = "start"
-    if align == "right":
-        warnings.warn("align='right' does not exists, you probably want align='end' instead")
-        align = "end"
-    # valid css options, but we don't list them as options to avoid confusion
-    extra_align_options = ["flex-start", "flex-end", "self-start", "self-end", "baseline"]
-    if align not in (["start", "center", "end", "stretch"] + extra_align_options):
-        warnings.warn(f"Invalid value for align: {align}, possible values are 'start', 'center', 'end' or 'stretch'")
-    style_flat = solara.util._flatten_style(style)
-    style_flat = f"flex-direction: column; align-items: {align}; row-gap: {gap};" + style_flat + ";"
-    class_ = _combine_classes(["d-flex", f"ma-{margin}", *classes])
-    return v.Sheet(class_=class_, style_=style_flat, elevation=0, children=children)
-
-
-@solara.component
-def GridFixed(columns=4, column_gap="10px", row_gap="10px", children=[], align_items="stretch", justify_items="stretch"):
-    """
-
-    See css grid spec:
-    https://css-tricks.com/snippets/css/complete-guide-grid/
-    """
-    style = (
-        f"display: grid; grid-template-columns: repeat({columns}, minmax(0, 1fr)); "
-        + f"grid-column-gap: {column_gap}; grid-row-gap: {row_gap}; align-items: {align_items}; justify-items: {justify_items}"
-    )
-    return Div(style_=style, children=children)
-
-
-@solara.component
-def Padding(size, children=[], grow=True):
-    style = "flex-direction: row;"
-    if grow:
-        style += "flex-grow: 1;"
-    return v.Sheet(class_=f"pa-{size}", style_=style, elevation=0, children=children)
-
-
-@solara.component
-def FigurePlotly(
-    fig,
-    on_selection: Callable[[Any], None] = None,
-    on_deselect: Callable[[Any], None] = None,
-    on_click: Callable[[Any], None] = None,
-    on_hover: Callable[[Any], None] = None,
-    on_unhover: Callable[[Any], None] = None,
-    on_relayout: Callable[[Any], None] = None,
-    dependencies=None,
-):
-    from plotly.graph_objs._figurewidget import FigureWidget
-
-    def on_points_callback(data):
-        if not data:
-            return
-
-        event_type = data["event_type"]
-        event_mapping = {
-            "plotly_click": on_click,
-            "plotly_hover": on_hover,
-            "plotly_unhover": on_unhover,
-            "plotly_selected": on_selection,
-            "plotly_deselect": on_deselect,
-        }
-
-        callback = event_mapping.get(event_type)
-        if callback:
-            callback(data)
-
-    fig_element = FigureWidget.element(on__js2py_pointsCallback=on_points_callback, on__js2py_relayout=on_relayout)
-
-    def update_data():
-        fig_widget: FigureWidget = solara.get_widget(fig_element)
-        fig_widget.layout = fig.layout
-
-        length = len(fig_widget.data)
-        fig_widget.add_traces(fig.data)
-        data = list(fig_widget.data)
-        fig_widget.data = data[length:]
-
-    solara.use_effect(update_data, dependencies or fig)
-    return fig_element
-
-
-@solara.component
-def Code(path, path_header=None):
-    path_header = path_header or path
-    with open(path) as f:
-        code = f.read()
-    md = solara.Markdown(
-        f"""
-### {path_header}
-
-```python
-{code}
-```
-
-"""
-    )
-
-    with v.ExpansionPanels() as main:
-        with v.ExpansionPanel():
-            with v.ExpansionPanelHeader(children=["View source"]):
-                pass
-            with v.ExpansionPanelContent(children=[md]):
-                pass
-    return main

solara/components/pivot_table.py

@@ -1,258 +0,0 @@
-import operator
-import os
-from functools import reduce
-from typing import Any, Callable, Dict, List, NoReturn
-
-import ipyvuetify as v
-
-try:
-    import numpy as np
-except ModuleNotFoundError:
-    np = None  # type: ignore
-import traitlets
-
-import solara
-from solara.alias import rv
-from solara.lab.hooks.dataframe import use_df_column_names
-
-cardheight = "100%"
-
-
-class PivotTableWidget(v.VuetifyTemplate):
-    template_file = os.path.realpath(os.path.join(os.path.dirname(__file__), "pivot_table.vue"))
-    d = traitlets.Dict(default_value={"no": "data"}).tag(sync=True)
-    selected = traitlets.Dict(default_value=[]).tag(sync=True)
-    style_ = traitlets.Unicode("").tag(sync=True)
-
-
-def assert_never(value) -> NoReturn:
-    # This also works at runtime as well
-    assert False, f"This code should never be reached, got: {value}"
-
-
-def translate_agg_to_vaex(aggregation: solara.Aggregation, filter=None):
-    if aggregation["type"] == "count":
-        import vaex
-
-        return vaex.agg.count(selection=filter) if filter else vaex.agg.count()
-    assert_never(aggregation)
-
-
-def df_aggregate_vaex(df, columns: List[str], aggregations: Dict[str, solara.Aggregation], filter=None):
-    aggs = {key: translate_agg_to_vaex(agg, filter) for key, agg, in aggregations.items()}
-    return df.groupby(columns, sort=True).agg(aggs)
-
-
-def df_aggregate_pivot_vaex(df, x: List[str], y: List[str], aggregation: solara.Aggregation, filter=None) -> solara.PivotTableData:
-    agg_name = aggregation["type"]
-
-    columns = [*x, *y]
-    agg_column = "agg_count__"
-    row_index = "__row_index__"
-
-    aggregations = {agg_column: aggregation}
-    if x and y:
-        dfg = df_aggregate_vaex(df, columns, aggregations, filter=filter)
-    else:
-        dfg = None
-    if x:
-        dfgx = df_aggregate_vaex(df, x, aggregations, filter=filter)
-        dfgx[row_index] = np.arange(len(dfgx), dtype="int64")
-    else:
-        dfgx = None
-    if y:
-        dfgy = df_aggregate_vaex(df, y, aggregations, filter=filter)
-        dfgy[row_index] = np.arange(len(dfgy), dtype="int64")
-    else:
-        dfgy = None
-    dfg_total = df._agg(translate_agg_to_vaex(aggregations[agg_column], filter=filter))
-
-    def formatter(value):
-        if isinstance(value, float):
-            return f"{value:,.2f}"
-        else:
-            return f"{value:,d}"
-
-    if x and y:
-        values: List[List[solara.JsonType]] = [[None] * len(dfgy) for _ in range(len(dfgx))]
-    else:
-        values = [[]]
-    if x:
-        values_x = list(map(formatter, dfgx[agg_column].tolist()))
-        headers_x = [dfgx[k].tolist() for k in x]
-        counts_x = len(dfgx)
-    else:
-        values_x = []
-        headers_x = []
-        counts_x = 0
-    if y:
-        values_y = list(map(formatter, dfgy[agg_column].tolist()))
-        headers_y = [dfgy[k].tolist() for k in y]
-        counts_y = len(dfgy)
-    else:
-        values_y = []
-        headers_y = []
-        counts_y = 0
-    total = formatter(dfg_total)
-
-    if x and y:
-        for row in dfg.to_records():
-            dfs = {"x": dfgx, "y": dfgy}
-            for column in columns:
-                axis_name = "x" if column in x else "y"
-                df_axis = dfs[axis_name]
-                if row[column] is None:
-                    df_axis = df_axis[df[column].ismissing()]
-                else:
-                    df_axis = df_axis[df_axis[column] == row[column]]
-                dfs[axis_name] = df_axis
-            assert len(dfs["x"])
-            assert len(dfs["y"])
-            xi = dfs["x"][row_index].tolist()[0]
-            yi = dfs["y"][row_index].tolist()[0]
-            value = row[agg_column]
-            values[xi][yi] = formatter(value)
-
-    data: solara.PivotTableData = {
-        "x": x,
-        "y": y,
-        "agg": agg_name,
-        "values": values,
-        "values_x": values_x,
-        "values_y": values_y,
-        "headers_x": headers_x,
-        "headers_y": headers_y,
-        "counts_x": counts_x,
-        "counts_y": counts_y,
-        "total": total,
-    }
-    return data
-
-
-def use_df_pivot_data(df, x: List[str], y: List[str], aggregation: solara.Aggregation, filter=None) -> solara.Result[solara.PivotTableData]:
-    return solara.use_thread(lambda: df_aggregate_pivot_vaex(df, x, y, aggregation, filter=filter), dependencies=[*x, *y, aggregation, filter])
-
-
-@solara.component
-def PivotTableView(data: solara.PivotTableData, selected: Dict[str, Any] = {}, on_selected: Callable[[Dict[str, Any]], None] = None, style=""):
-    return PivotTableWidget.element(d=data, selected=selected, on_selected=on_selected, style_=style)
-
-
-@solara.component
-def PivotTable(
-    df,
-    x: List[str] = [],
-    y: List[str] = [],
-    aggregation: solara.Aggregation = solara.AggregationCount(type="count"),
-    selected: Dict[str, Any] = {},
-    on_selected: Callable[[Dict[str, Any]], None] = None,
-):
-    x = x.copy()
-    y = y.copy()
-    filter, set_filter = solara.use_cross_filter(id(df), "pivottable")
-    dff = df
-    data_result = use_df_pivot_data(dff, x, y, aggregation, filter=filter)
-    previous = solara.use_previous(data_result.value, condition=data_result.state == solara.ResultState.FINISHED)
-    selected, set_selected = solara.use_state_or_update(selected.copy())
-
-    def set_filter_from_pivot_selection(selection):
-        set_selected(selection)
-        if on_selected:
-            on_selected(selection)
-        data = data_result.value
-        if data is None:
-            return
-        # assert data is not None
-        filters = []
-        if "x" in selection:
-            sel = selection["x"]
-            for level in range(sel[0] + 1):
-                value = data["headers_x"][level][sel[1]]
-                column = data["x"][level]
-                if value is None:
-                    filters.append(df[column].ismissing())
-                else:
-                    filters.append(df[column] == value)
-
-        if "y" in selection:
-            sel = selection["y"]
-            for level in range(sel[0] + 1):
-                column = data["y"][level]
-                value = data["headers_y"][level][sel[1]]
-                if value is None:
-                    filters.append(df[column].ismissing())
-                else:
-                    filters.append(df[column] == value)
-        if filters:
-            filter = reduce(operator.and_, filters[1:], filters[0])
-        else:
-            filter = None
-        set_filter(filter if filter is not None else None)
-
-    # Bug in use_thread on state result we remember that state is finished
-    if data_result.state == solara.ResultState.FINISHED and data_result.value is not None:
-        with solara.VBox() as main:
-            rv.ProgressLinear(indeterminate=False, style_="visibility: hidden;")
-            PivotTableView(data=data_result.value, selected=selected, on_selected=set_filter_from_pivot_selection)
-    elif previous is not None:
-        with solara.VBox() as main:
-            rv.ProgressLinear(indeterminate=True)
-            PivotTableView(data=previous, selected=selected, on_selected=set_filter_from_pivot_selection, style="opacity: 0.3; pointer-events: none;")
-    elif data_result.state == solara.ResultState.ERROR:
-        return solara.Error(f"Oops: {data_result.error}")
-    else:
-        return solara.Info(f"Status: {data_result.state}")
-    return main
-
-
-@solara.component
-def PivotTableCard(
-    df,
-    x=[],
-    y=[],
-    selected: Dict[str, Any] = {},
-    on_selected: Callable[[Dict[str, Any]], None] = None,
-):
-    items = use_df_column_names(df)
-    with rv.Card(elevation=2, style_="position: relative", height=cardheight) as main:
-        with rv.CardTitle(children=["Pivot table"]):
-            pass
-        with rv.CardText():
-            with rv.Btn(v_on="x.on", icon=True, absolute=True, style_="right: 10px; top: 10px") as btn:
-                rv.Icon(children=["mdi-settings"])
-            with rv.Dialog(v_slots=[{"name": "activator", "variable": "x", "children": btn}]):
-                with rv.Sheet():
-                    with rv.Container(pa_4=True, ma_0=True):
-                        with rv.Row():
-                            with rv.Col():
-                                with rv.Card(elevation=2):
-                                    with rv.CardTitle(children=["Rows"]):
-                                        pass
-                                    with rv.CardText():
-                                        for i in range(10):
-                                            col = solara.ui_dropdown(value=x[i] if i < len(x) else None, label=f"Row {i}", options=items)
-                                            if col is None:
-                                                break
-                                            else:
-                                                if i < len(x):
-                                                    x[i] = col
-                                                else:
-                                                    x.append(col)
-                            with rv.Col():
-                                with rv.Card(elevation=2):
-                                    with rv.CardTitle(children=["Columns"]):
-                                        pass
-                                    with rv.CardText():
-                                        for i in range(10):
-                                            col = solara.ui_dropdown(value=y[i] if i < len(y) else None, label=f"Column {i}", options=items)
-                                            if col is None:
-                                                break
-                                            else:
-                                                if i < len(y):
-                                                    y[i] = col
-                                                else:
-                                                    y.append(col)
-
-            PivotTable(df, x, y, selected=selected, on_selected=on_selected)
-
-    return main