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

solara/components/tooltip.py

@@ -1,61 +0,0 @@
-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/datatypes.py

@@ -1,143 +0,0 @@
-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

@@ -1,241 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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