solara-ui 1.45.0__py3-none-any.whl

solara/components/tooltip.py

@@ -0,0 +1,61 @@
+from typing import Optional, Union
+
+import reacton.ipyvuetify as v
+
+import solara
+
+
+@solara.component
+def Tooltip(
+    tooltip: Union[str, solara.Element],
+    children=[],
+    color: Optional[str] = None,
+):
+    """A tooltip that is shown when you hover above an element.
+
+    Not all components support tooltips, in case it does not work,
+    try wrapping the element in a `Column` or `Row`.
+
+    ```solara
+    import solara
+
+    @solara.component
+    def Page():
+        with solara.Tooltip("This is a tooltip over a button"):
+            solara.Button("Hover me")
+        with solara.Tooltip("This is a tooltip over a text"):
+            solara.Text("Hover me")
+        info = solara.Info("Any component is supported as tooltip.")
+        with solara.Tooltip(info, color="white"):
+            with solara.Column():
+                solara.Markdown("# Lorem ipsum\\n\\nDolor sit amet")
+    ```
+
+    ## Arguments
+
+     * `tooltip`: the text, or element to display on hover.
+     * `children`: the element to display the tooltip over.
+     * `color`: the color of the tooltip (if None, the default color).
+
+    """
+
+    def set_v_on():
+        for child in children:
+            widget = solara.get_widget(child)
+            # this only works on vue/vuetify components
+            widget.v_on = "tooltip.on"  # type: ignore
+
+    solara.use_effect(set_v_on, children)
+
+    return v.Tooltip(
+        bottom=True,
+        v_slots=[
+            {
+                "name": "activator",
+                "variable": "tooltip",
+                "children": children,
+            }
+        ],
+        color=color,
+        children=[tooltip],
+    )

solara/core.py

@@ -0,0 +1,42 @@
+import warnings
+from typing import Any, Callable, Dict, Union, overload, TypeVar
+import typing_extensions
+import reacton
+from . import validate_hooks
+
+
+P = typing_extensions.ParamSpec("P")
+FuncT = TypeVar("FuncT", bound=Callable[..., reacton.core.Element])
+
+
+@overload
+def component(obj: None = None, mime_bundle: Dict[str, Any] = ...) -> Callable[[FuncT], FuncT]: ...
+
+
+@overload
+def component(obj: FuncT, mime_bundle: Dict[str, Any] = ...) -> FuncT: ...
+
+
+@overload
+def component(obj: Callable[P, None], mime_bundle: Dict[str, Any] = ...) -> Callable[P, reacton.core.Element]: ...
+
+
+def component(
+    obj: Union[Callable[P, None], FuncT, None] = None, mime_bundle: Dict[str, Any] = reacton.core.mime_bundle_default
+) -> Union[Callable[[FuncT], FuncT], FuncT, Callable[P, reacton.core.Element]]:
+    def wrapper(obj: Union[Callable[P, None], FuncT]) -> FuncT:
+        try:
+            validate_hooks.HookValidator(obj).run()
+        except Exception as e:
+            if not isinstance(e, validate_hooks.HookValidationError):
+                # we probably failed because of an unknown reason, but we do not want to break the user's code
+                warnings.warn(f"Failed to validate hooks for component {obj.__qualname__}: {e}")
+            else:
+                raise
+
+        return reacton.component(obj, mime_bundle)  # type: ignore
+
+    if obj is not None:
+        return wrapper(obj)
+    else:
+        return wrapper

solara/datatypes.py

@@ -0,0 +1,143 @@
+import dataclasses
+from enum import Enum
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Union
+
+import reacton
+from typing_extensions import Literal, TypedDict
+
+T = TypeVar("T")
+U = TypeVar("U")
+
+
+@dataclasses.dataclass(frozen=True)
+class Action:
+    name: str
+    icon: Optional[str] = None
+    on_click: Optional[Callable] = None
+
+
+@dataclasses.dataclass(frozen=True)
+class ColumnAction(Action):
+    on_click: Optional[Callable[[str], None]] = None
+
+
+@dataclasses.dataclass(frozen=True)
+class CellAction(Action):
+    on_click: Optional[Callable[[str, int], None]] = None
+
+
+def _fallback_retry():
+    raise RuntimeError("Should not happen")
+
+
+class ResultState(Enum):
+    INITIAL = 1
+    STARTING = 2
+    WAITING = 3
+    RUNNING = 4
+    ERROR = 5
+    FINISHED = 6
+    CANCELLED = 7
+
+
+@dataclasses.dataclass(frozen=True)
+class Result(Generic[T]):
+    value: Optional[T] = None
+    error: Optional[Exception] = None
+    state: ResultState = ResultState.INITIAL
+    progress: Optional[float] = None
+
+    def retry(self):
+        # mypy does not like members that are callable
+        # gets confused about self argument.
+        # we wrap it to avoid hitting this error in user
+        # code
+        self._retry()  # type: ignore
+
+    # can we avoid storing these into the dataclass?
+    _retry: Callable[[], Any] = dataclasses.field(compare=False, default=lambda: None)
+    cancel: Callable[[], Any] = dataclasses.field(compare=False, default=lambda: None)
+
+    def __or__(self, next: Callable[["Result[T]"], "Result[U]"]):
+        return next(self)
+
+
+@dataclasses.dataclass(frozen=True)
+class FileContentResult(Result[T]):
+    @property
+    def exists(self):
+        return not isinstance(self.error, FileNotFoundError)
+
+
+class AggregationCount(TypedDict):
+    type: Literal["count"]
+
+
+class AggregationSum(TypedDict):
+    type: Literal["sum"]
+
+
+JsonType = Union[None, int, str, bool, List[Any], Dict[str, Any]]
+
+Aggregation = Union[AggregationCount, AggregationSum]
+
+
+class PivotTableData(TypedDict):
+    x: List[str]
+    y: List[str]
+    agg: str
+    values: List[List[JsonType]]
+    values_x: List[str]
+    values_y: List[str]
+    headers_x: List[List[str]]
+    headers_y: List[List[str]]
+    counts_x: int
+    counts_y: int
+    total: str
+
+
+@dataclasses.dataclass(frozen=True)
+class Route:
+    """A route tells Solara which component to render for a given URL. (Not a Solara component!)
+
+    ## Arguments
+
+     * `path` - The path of the route. This is the part of the URL that you see in the browser.
+     * `children` - (Optional) A list of child routes. These are routes that are nested under this route.
+     * `module` - (Optional) The module that contains the component to render for this route, used for autorouting.
+     * `component` - (Optional) The component to render for this route.
+     * `layout` - (Optional) The layout to use for this route. If not specified, the default layout will be used.
+     * `data` - (Optional) The data to pass to the component for this route, usage is up to the user.
+     * `label` - (Optional) The label to use for this route, can be used for labeling tabs or links.
+
+    ## See also
+
+     * [Multipage](/documentation/advanced/howto/multipage).
+     * [Understanding Routing](/documentation/advanced/understanding/routing).
+
+    """
+
+    path: str
+    children: List["Route"] = dataclasses.field(default_factory=list)
+
+    # these are free to use, depending on the implementation
+    # see autorouting.py for how Solara uses them
+    module: Optional[ModuleType] = None
+
+    # in the autorouting implementation, this is the
+    # the same as module.Page (unless we are rendering a markdown)
+    component: Union[None, Callable, reacton.core.Component] = None
+    layout: Union[None, Callable, reacton.core.Component] = None
+
+    # in the autorouting implementation, this is the
+    # path of the markdown file
+    data: Any = None
+
+    # Can be used for a title and/or a tab label
+    label: Optional[str] = None
+
+    # file corresponding to this route, can be used for
+    # checking of content has changed (using mtime)
+    file: Optional[Path] = None

solara/express.py

@@ -0,0 +1,241 @@
+import functools
+import typing
+from typing import Callable
+
+import numpy as np
+import plotly.express as px
+import plotly.graph_objs as go
+import typing_extensions
+
+# behave as the px module
+from plotly.express import *  # noqa: F401, F403
+from plotly.express._core import make_figure
+
+import solara
+
+P = typing_extensions.ParamSpec("P")
+T = typing.TypeVar("T")
+T2 = typing.TypeVar("T2")
+
+
+# patch histogram until issue 3859 in plotly is resolved
+
+
+def histogram(
+    data_frame=None,
+    x=None,
+    y=None,
+    custom_data=None,
+    color=None,
+    pattern_shape=None,
+    facet_row=None,
+    facet_col=None,
+    facet_col_wrap=0,
+    facet_row_spacing=None,
+    facet_col_spacing=None,
+    hover_name=None,
+    hover_data=None,
+    animation_frame=None,
+    animation_group=None,
+    category_orders=None,
+    labels=None,
+    color_discrete_sequence=None,
+    color_discrete_map=None,
+    pattern_shape_sequence=None,
+    pattern_shape_map=None,
+    marginal=None,
+    opacity=None,
+    orientation=None,
+    barmode="relative",
+    barnorm=None,
+    histnorm=None,
+    log_x=False,
+    log_y=False,
+    range_x=None,
+    range_y=None,
+    histfunc=None,
+    cumulative=None,
+    nbins=None,
+    text_auto=False,
+    title=None,
+    template=None,
+    width=None,
+    height=None,
+) -> go.Figure:
+    """
+    In a histogram, rows of `data_frame` are grouped together into a
+    rectangular mark to visualize the 1D distribution of an aggregate
+    function `histfunc` (e.g. the count or sum) of the value `y` (or `x` if
+    `orientation` is `'h'`).
+    """
+    return make_figure(
+        args=locals(),
+        constructor=go.Histogram,
+        trace_patch=dict(
+            histnorm=histnorm,
+            histfunc=histfunc,
+            cumulative=dict(enabled=cumulative),
+        ),
+        layout_patch=dict(barmode=barmode, barnorm=barnorm),
+    )
+
+
+px.histogram = histogram
+
+
+def _make_self_describing(f: Callable[P, T]):
+    # put the arguments on the function and the function into the return value
+    if hasattr(f, "__wrapped__"):
+        # on hot reload, we need to unwrap the function to not wrap it twice
+        f = f.__wrapped__
+
+    @functools.wraps(f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs):
+        fig = f(*args, **kwargs)
+        fig._func = f  # type: ignore
+        fig._args = args  # type: ignore
+        fig._kwargs = kwargs  # type: ignore
+        return fig
+
+    return wrapper
+
+
+def _patch():
+    for name in dir(px):
+        f = getattr(px, name)
+        if callable(f):
+            f = _make_self_describing(f)
+            setattr(px, name, f)
+
+
+_patch()
+
+
+@solara.component
+def CrossFilteredFigurePlotly(fig):
+    first_arg_name = fig._func.__code__.co_varnames[0]
+    kwargs = fig._kwargs.copy()
+    kwargs.update(zip(fig._func.__code__.co_varnames, fig._args))
+
+    df = kwargs[first_arg_name]
+    name = fig._func.__name__
+    filter, set_filter = solara.use_cross_filter(id(df), name)
+    dff = df
+    if filter is not None:
+        dff = df[filter]
+        for key, value in kwargs.items():
+            if not isinstance(value, str):
+                try:
+                    n = len(value)
+                except TypeError:
+                    pass  # int or bool, or anything without a length
+                except Exception:
+                    raise
+                else:
+                    if n == len(df):
+                        kwargs[key] = np.array(value)[filter]
+        original_indices = np.arange(len(df), dtype="int64")
+    else:
+        original_indices = None
+
+    kwargs[first_arg_name] = dff
+
+    index = np.arange(len(dff))
+    custom_data = [index]
+    has_custom_data = "custom_data" in kwargs
+
+    if has_custom_data:
+        kwargs["custom_data"] = custom_data + list(kwargs["custom_data"])
+    else:
+        kwargs["custom_data"] = custom_data
+    new_fig = fig._func(**kwargs)
+    new_fig.layout = fig.layout
+
+    # the df is split into multiple traces, generate the data such that we can transform back from trace+point indices to df.index
+    indices = []
+    offset = 0
+    index_offsets_list = []
+    for data in new_fig.data:
+        indices.append(data.customdata.T[0])
+        index_offsets_list.append(offset)
+        offset += len(data.customdata.T[0])
+    index_offsets = np.array(index_offsets_list)
+    # strip of the custom data we added
+    for data in new_fig.data:
+        if has_custom_data:
+            data.customdata = data.customdata.T[len(custom_data) :].T
+        else:
+            data.customdata = None
+
+    def on_selection(data):
+        if data is not None:
+            trace_indexes = np.array(data["points"]["trace_indexes"])
+            point_indexes = np.array(data["points"]["point_indexes"])
+            if len(trace_indexes):
+                indices_selected = index_offsets[trace_indexes] + point_indexes
+
+                if filter is not None:
+                    assert original_indices is not None
+                    # these are references to the filtered dataframe
+                    indices_selected = original_indices[filter][indices_selected]
+                mask = np.zeros(len(df), dtype=bool)
+                mask[indices_selected] = True
+                set_filter(mask)
+            else:
+                set_filter(None)
+
+    def on_deselect(data):
+        set_filter(None)
+
+    return solara.FigurePlotly(new_fig, on_selection=on_selection, on_deselect=on_deselect)
+
+
+# for backwards compatibility
+FigurePlotlyCrossFiltered = CrossFilteredFigurePlotly
+
+
+def _wraps(f: Callable[P, T]):
+    @functools.wraps(f)
+    def wrapper(*args: P.args, **kwargs: P.kwargs):
+        fig = f(*args, **kwargs)
+        return CrossFilteredFigurePlotly(fig)
+
+    return wrapper
+
+
+scatter = _wraps(px.scatter)
+scatter_3d = _wraps(px.scatter_3d)
+scatter_polar = _wraps(px.scatter_polar)
+scatter_ternary = _wraps(px.scatter_ternary)
+scatter_mapbox = _wraps(px.scatter_mapbox)
+scatter_geo = _wraps(px.scatter_geo)
+scatter_matrix = _wraps(px.scatter_matrix)
+density_contour = _wraps(px.density_contour)
+density_heatmap = _wraps(px.density_heatmap)
+density_mapbox = _wraps(px.density_mapbox)
+line = _wraps(px.line)
+line_3d = _wraps(px.line_3d)
+line_polar = _wraps(px.line_polar)
+line_ternary = _wraps(px.line_ternary)
+line_mapbox = _wraps(px.line_mapbox)
+line_geo = _wraps(px.line_geo)
+parallel_coordinates = _wraps(px.parallel_coordinates)
+parallel_categories = _wraps(px.parallel_categories)
+area = _wraps(px.area)
+bar = _wraps(px.bar)
+timeline = _wraps(px.timeline)
+bar_polar = _wraps(px.bar_polar)
+violin = _wraps(px.violin)
+box = _wraps(px.box)
+strip = _wraps(px.strip)
+histogram = _wraps(px.histogram)
+ecdf = _wraps(px.ecdf)
+choropleth = _wraps(px.choropleth)
+choropleth_mapbox = _wraps(px.choropleth_mapbox)
+pie = _wraps(px.pie)
+sunburst = _wraps(px.sunburst)
+treemap = _wraps(px.treemap)
+icicle = _wraps(px.icicle)
+funnel = _wraps(px.funnel)
+funnel_area = _wraps(px.funnel_area)
+imshow = _wraps(px.imshow)

solara/hooks/__init__.py

@@ -0,0 +1,4 @@
+from .dataframe import *  # noqa: F401 F403
+from .misc import *  # noqa: F401 F403
+from .use_reactive import use_reactive  # noqa: F401 F403
+from .use_thread import use_thread  # noqa: F401 F403

solara/hooks/dataframe.py

@@ -0,0 +1,99 @@
+import operator
+from functools import reduce
+from typing import Any, Callable, Dict, List, TypeVar
+
+import solara.util
+from solara.hooks.misc import use_force_update, use_unique_key
+
+T = TypeVar("T")
+
+__all__ = [
+    "provide_cross_filter",
+    "use_cross_filter",
+]
+
+
+class CrossFilterStore:
+    def __init__(self) -> None:
+        self.listeners: List[Callable] = []
+        self.filters: Dict[Any, Dict[str, Any]] = {}
+
+    def add(self, data_key, key, filter):
+        data_filters = self.filters.setdefault(data_key, {})
+        data_filters[key] = filter
+
+    def use(self, data_key, key, eq=None):
+        # we use this state to trigger update, we could do without
+        updater = use_force_update()
+
+        data_filters = self.filters.setdefault(data_key, {})
+        filter, set_filter = solara.use_state(data_filters.get(key), eq=eq)
+
+        def on_change():
+            set_filter(data_filters.get(key))
+            # even if we don't change our own filter, the other may change
+            updater()
+
+        def connect():
+            self.listeners.append(on_change)
+            # we need to force an extra render after the first render
+            # to make sure we have the correct filter, since others components
+            # may set a filter after we have rendered, *or* mounted
+            on_change()
+
+            def cleanup():
+                self.listeners.remove(on_change)
+                # also remove our filter, and notify the rest
+                data_filters.pop(key, None)  # remove, ignoring key error
+                for listener in self.listeners:
+                    listener()
+
+            return cleanup
+
+        solara.use_effect(connect, [key])
+
+        def setter(filter):
+            data_filters[key] = filter
+            for listener in self.listeners:
+                listener()
+
+        otherfilters = [filter for key_other, filter in data_filters.items() if key != key_other and filter is not None]
+        return filter, otherfilters, setter
+
+
+cross_filter_context = solara.create_context(CrossFilterStore())
+
+
+def provide_cross_filter():
+    # create it once
+    cross_filter_object = solara.use_memo(CrossFilterStore, [])
+    cross_filter_context.provide(cross_filter_object)
+    return cross_filter_object
+
+
+def use_cross_filter(data_key, name: str = "no-name", reducer: Callable[[T, T], T] = operator.and_, eq=solara.util.numpy_equals):
+    """Provides cross filtering, all other filters are combined using the reducer.
+
+    Cross filtering will collect a set of filters (from other components), and combine
+    them into a single filter, that excludes the filter we set for the current component.
+    This is often used in dashboards where a filter is defined in a visualization component,
+    but only applied to all other components.
+
+    The graph below shows what happens when component A and B set a filter, and C does not.
+
+    ```mermaid
+    graph TD;
+        A--"filter A"-->B;
+        B--"filter B"-->C;
+        A--"filter A"-->C;
+        B--"filter B"-->A;
+    ```
+    """
+    key = use_unique_key(prefix=f"cross-filter-{name}-")
+    cross_filter_store = solara.use_context(cross_filter_context)
+    _own_filter, otherfilters, set_filter = cross_filter_store.use(data_key, key, eq=eq)
+    if otherfilters:
+        cross_filter = reduce(reducer, otherfilters[1:], otherfilters[0])
+    else:
+        cross_filter = None
+    return cross_filter, set_filter