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

solara/lab/utils/dataframe.py

@@ -1,115 +0,0 @@
-def get_pandas_major():
-    import pandas as pd
-
-    return int(pd.__version__[0])
-
-
-def df_type(df):
-    return df.__class__.__module__.split(".")[0]
-
-
-def df_unique(df, column, limit=None):
-    if df_type(df) == "vaex":
-        return df.unique(column, limit=limit + 1 if limit else None, limit_raise=False)
-    if df_type(df) == "pandas":
-        x = df[column].unique()  # .to_numpy()
-        return x[:limit]
-    else:
-        raise TypeError(f"{type(df)} not supported")
-
-
-def df_value_count(df, column, limit=None):
-    if df_type(df) == "vaex":
-        dfv = df.groupby(column, agg="count", sort="count", ascending=False)
-        dfv = dfv.to_pandas_df().rename({column: "value"}, axis=1)
-        return dfv[:limit]
-    if df_type(df) == "pandas":
-        dfv = df[column].value_counts(dropna=False).to_frame()
-        dfv = dfv.reset_index()
-        if get_pandas_major() >= 2:
-            dfv = dfv.rename({column: "value"}, axis=1)
-        else:
-            dfv = dfv.rename({"index": "value", column: "count"}, axis=1)
-        return dfv[:limit]
-    else:
-        raise TypeError(f"{type(df)} not supported")
-
-
-def df_range(df, column):
-    if df_type(df) == "vaex":
-        minmax = df[column].minmax()
-        return minmax[0].item(), minmax[1].item()
-    if df_type(df) == "pandas":
-        return df[column].min().item(), df[column].max().item()
-    else:
-        raise TypeError(f"{type(df)} not supported")
-
-
-def df_filter_missing(df, column):
-    if df_type(df) == "vaex":
-        return df[column].isna()
-    if df_type(df) == "pandas":
-        return df[column].isna()
-    else:
-        raise TypeError(f"{type(df)} not supported")
-
-
-def df_filter_values(df, column, values, invert=False):
-    if df_type(df) == "vaex":
-        filter = df[column].isin(values)
-        if invert:
-            filter = ~filter
-        return filter
-    if df_type(df) == "pandas":
-        filter = df[column].isin(values)
-        if invert:
-            filter = ~filter
-        return filter
-    else:
-        raise TypeError(f"{type(df)} not supported")
-
-
-def df_py_types(df):
-    """Return a dict with column names as keys and python types as values.
-
-    Support types are
-        * int
-        * float
-        * str
-        * bool
-
-    If a type is not supported, the internal type is returned.
-
-    """
-    import numpy as np
-
-    if df_type(df) == "vaex":
-        schema = df.schema()
-        py_types = [int, float, str, bool]
-
-        def py_type(dtype):
-            for k in py_types:
-                if dtype == k:
-                    return k
-            return dtype
-
-        return {name: py_type(dtype) for name, dtype in schema.items()}
-    elif df_type(df) == "pandas":
-        schema = df.dtypes
-
-        def py_type(dtype):
-            if isinstance(dtype, np.dtype):
-                if dtype.kind in "iu":
-                    return int
-                elif dtype.kind == "f":
-                    return float
-                elif dtype.kind == "b":
-                    return bool
-                else:
-                    return dtype
-            else:
-                return dtype
-
-        return {name: py_type(dtype) for name, dtype in schema.items()}
-    else:
-        raise TypeError(f"{type(df)} not supported")

solara/lab/utils/headers.py

@@ -1,5 +0,0 @@
-from typing import Dict, List, Optional, cast
-
-from solara.toestand import Reactive
-
-headers: Reactive[Optional[Dict[str, List[str]]]] = Reactive(cast(Optional[Dict[str, List[str]]], None), key="solara.lab.headers")

solara/layout.py

@@ -1,44 +0,0 @@
-import reacton.ipyvuetify as v
-import solara
-from solara.kitchensink import vue
-
-
-@solara.component
-def AppIcon(open=False, on_click=None):
-    def click(*ignore):
-        on_click()
-
-    icon = v.AppBarNavIcon()
-    v.use_event(icon, "click", click)
-    return icon
-
-
-@solara.component
-def LayoutApp(children=[], left=None, right=None, open_left=False, open_right=False, title="Solara"):
-    open_left, set_open_left = solara.use_state(open_left)
-    open_right, set_open_right = solara.use_state(open_right)
-    with v.Html(tag="div") as main:
-        if left:
-            with v.NavigationDrawer(absolute=True, right=False, width="min-content", v_model=open_left):
-                AppIcon(open_left, on_click=lambda: set_open_left(not open_left))
-                with v.Html(tag="div", children=[left]):
-                    pass
-        with v.Toolbar(dense=True, class_="elevation-3", dark=False):
-            if left:
-                AppIcon(open_left, on_click=lambda: set_open_left(not open_left))
-            v.ToolbarTitle(children=[title])
-            v.Spacer()
-            if right:
-                with v.Btn(icon=True) as btn:
-                    vue.use_event(btn, "click", lambda *_ignore: set_open_right(not open_right))
-                    v.Icon(children=["mdi-settings"])
-        with v.Row():
-            v.Col(cols=12, children=[*children])
-        if right:
-            with v.NavigationDrawer(absolute=True, right=True, width="min-content", v_model=open_right):
-                with v.Btn(icon=True) as btn:
-                    vue.use_event(btn, "click", lambda *_ignore: set_open_right(not open_right))
-                    v.Icon(children=["mdi-settings"])
-                with v.Html(tag="div", children=[right]):
-                    pass
-    return main

solara/minisettings.py

@@ -1,133 +0,0 @@
-import os
-from pathlib import Path
-from typing import Any, Optional
-
-# similar API to pydantic/pydantic-settings but we prefer not to have a dependency on pydantic
-# since we cannot be compatible with pydantic1 and 2
-# NOTE: not a public api
-
-
-def _get_type(annotation):
-    check_optional_types = [str, int, float, bool, dict, list]
-    for check_type in check_optional_types:
-        if annotation == Optional[check_type]:
-            return check_type
-    if hasattr(annotation, "__origin__"):
-        if annotation.__origin__ == dict:
-            return dict
-    return annotation
-
-
-class _Field:
-    def __init__(self, default=None, env=None, title=None, default_factory=None, gt=None, alias=None) -> None:
-        self.default = default
-        self.env = env
-        self.fullenv = None
-        self.title = title
-        self.annotation = None
-        self.default_factory = default_factory
-        self.gt = gt
-        self.alias = alias
-        self.field_info = self
-        self.extra = {"env_names": [env] if env else []}
-
-    def __set_name__(self, owner, name):
-        prefix = "SOLARA_"
-        config = getattr(owner, "Config")
-        if config:
-            prefix = getattr(config, "env_prefix", prefix).upper()
-            if hasattr(config, "fields"):
-                fields = config.fields
-                if name in fields:
-                    self.alias = fields[name]
-        self.name = name
-        self.alias = self.alias or self.name
-        self.title = self.title or self.name
-        if self.env is None:
-            self.env = f"{prefix}{self.name.upper()}"
-        else:
-            self.env = self.env
-        self.annotation = owner.__annotations__.get(self.name)
-        assert self.annotation is not None, f"Field {self.name} must have a type annotation"
-        self.type_ = _get_type(self.annotation)
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-        return instance._values[self.name]
-
-    def __set__(self, instance, value):
-        instance._values[self.name] = value
-
-
-def convert(annotation, value: str) -> Any:
-    check_optional_types = [str, int, float, bool, Path]
-    for check_type in check_optional_types:
-        if annotation == Optional[check_type]:
-            annotation = check_type
-            return convert(annotation, value)
-    if annotation == str:
-        return value
-    elif annotation == int:
-        return int(value)
-    elif annotation == float:
-        return float(value)
-    elif annotation == bool:
-        if value in ("True", "true", "1"):
-            return True
-        elif value in ("False", "false", "0"):
-            return False
-        else:
-            raise ValueError(f"Invalid boolean value {value}")
-    else:
-        # raise TypeError(f"Unsupported type {annotation}")
-        return annotation(value)
-
-
-def Field(*args, **kwargs) -> Any:
-    return _Field(*args, **kwargs)
-
-
-class BaseSettings:
-    __fields__: dict
-
-    def __init__(self, **kwargs) -> None:
-        cls = type(self)
-        self._values = {**kwargs}
-        keys = {k.upper() for k in os.environ.keys()}
-        for key, field in cls.__dict__.items():
-            if key in kwargs:
-                continue
-            if isinstance(field, _Field):
-                value = field.default
-                if field.default_factory:
-                    value = field.default_factory()
-
-                if field.env:
-                    env_key = field.env.upper()
-                    if env_key in keys:
-                        # do a case-insensitive lookup
-                        for env_var_cased in os.environ.keys():
-                            if env_key.upper() == env_var_cased.upper():
-                                value = convert(field.annotation, os.environ[env_var_cased])
-                self._values[key] = value
-
-    def __init_subclass__(cls) -> None:
-        cls.__fields__ = {}
-        for key, field in cls.__dict__.items():
-            if key.startswith("_"):
-                continue
-            if key == "Config":
-                continue
-            if not isinstance(field, _Field):
-                field = Field(field)
-                setattr(cls, key, field)
-                field.__set_name__(cls, key)
-            cls.__fields__[key] = field
-
-    def dict(self, by_alias=True):
-        values = self._values.copy()
-        for key, value in values.items():
-            if isinstance(value, BaseSettings):
-                values[key] = value.dict(by_alias=by_alias)
-        return values

solara/reactive.py

@@ -1,93 +0,0 @@
-from typing import TypeVar
-
-from solara.toestand import Reactive
-
-__all__ = ["reactive", "Reactive"]
-
-T = TypeVar("T")
-
-
-def reactive(value: T) -> Reactive[T]:
-    """Creates a new Reactive object with the given initial value.
-
-    Reactive objects are mostly used to manage global or application-wide state in
-    Solara web applications. They provide an easy-to-use mechanism for keeping
-    track of the changing state of data and for propagating those changes to
-    the appropriate UI components. For managing local or component-specific
-    state, consider using the [`solara.use_state()`](/documentation/api/hooks/use_state) function.
-
-
-    Reactive variables can be accessed using the `.value` attribute. To modify
-    the value, you can either set the `.value` property directly or use the
-    `.set()` method. While both approaches are equivalent, the `.set()` method
-    is particularly useful when you need to pass it as a callback function to
-    other components, such as a slider's `on_value` callback.
-
-    When a component uses a reactive variable, it
-    automatically listens for changes to the variable's value. If the value
-    changes, the component will automatically re-render to reflect the updated
-    state, without the need to explicitly subscribe to the variable.
-
-    Reactive objects in Solara are also context-aware, meaning that they can
-    maintain separate values for each browser tab or user session. This enables
-    each user to have their own independent state, allowing them to interact
-    with the web application without affecting the state of other users.
-
-    Args:
-        value (T): The initial value of the reactive variable.
-
-    Returns:
-        Reactive[T]: A new Reactive object with the specified initial value.
-
-    Example:
-
-    ```python
-    >>> counter = solara.reactive(0)
-    >>> counter.value
-    0
-    >>> counter.set(1)
-    >>> counter.value
-    1
-    >>> counter.value += 1
-    >>> counter.value
-    2
-    ```
-
-
-    ## Solara example
-
-    Here's an example that demonstrates the use of reactive variables in Solara components:
-
-    ```solara
-    import solara
-
-    counter = solara.reactive(0)
-
-    def increment():
-        counter.value += 1
-
-
-    @solara.component
-    def CounterDisplay():
-        solara.Info(f"Counter: {counter.value}")
-
-
-    @solara.component
-    def IncrementButton():
-
-        solara.Button("Increment", on_click=increment)
-
-
-    @solara.component
-    def Page():
-        IncrementButton()
-        CounterDisplay()
-    ```
-
-    In this example, we create a reactive variable counter with an initial value of 0.
-    We define two components: `CounterDisplay` and `IncrementButton`. `CounterDisplay` renders the current value of counter,
-    while `IncrementButton` increments the value of counter when clicked.
-    Whenever the counter value changes, `CounterDisplay` automatically updates to display the new value.
-
-    """
-    return Reactive(value)

solara/routing.py

@@ -1,268 +0,0 @@
-import abc
-import logging
-from typing import Callable, List, Optional, Tuple, Union, cast
-
-import solara
-from solara import _using_solara_server
-
-logger = logging.getLogger("solara.router")
-
-
-class _LocationBase(abc.ABC):
-    @property
-    def pathname(self):
-        pass
-
-    @pathname.setter
-    # mypy does not accept this
-    # @abc.abstractmethod
-    def pathname(self):
-        pass
-
-
-class _Location(_LocationBase):
-    def __init__(self, pathname, setter: Callable[[str], None]) -> None:
-        self._pathname = pathname
-        self.setter = setter
-
-    @property
-    def pathname(self):
-        return self._pathname
-
-    @pathname.setter
-    def pathname(self, value):
-        # import pdb
-
-        # pdb.set_trace()
-        self._pathname = value
-        self.setter(self._pathname)
-
-
-class Router:
-    search: Optional[str]
-
-    def __init__(self, path: str, routes: List[solara.Route], set_path: Callable[[str], None] = None):
-        # see https://developer.mozilla.org/en-US/docs/Web/API/Location for anatomy/nomenclature
-        if "?" in path:
-            self.path, self.search = path.split("?", 1)
-        else:
-            self.path = path
-            self.search = None
-        del path
-        self.set_path = set_path
-        self.parts = (self.path or "").strip("/").split("/")
-        self.routes = routes
-        self.root_path = ""
-        if _using_solara_server():
-            import solara.server.settings
-
-            self.root_path = solara.server.settings.main.root_path or ""
-        # each route in this list corresponds to a part in self.parts
-        self.path_routes: List["solara.Route"] = []
-        self.path_routes_siblings: List[List["solara.Route"]] = []  # siblings including itself
-        # routes = routes.copy()
-        route = None
-        for part in self.parts:
-            for route in routes:
-                if (route.path == part) or (route.path == "/" and not part):
-                    self.path_routes.append(route)
-                    self.path_routes_siblings.append(routes)
-                    routes = route.children
-                    break
-        if len(self.parts) == len(self.path_routes):
-            # e.g. '/foo/bar' -> ['foo', 'bar'] and bar has a default route
-            # but if '' -> [''] we should not
-            route = self.path_routes[-1]
-            if route:
-                default_routes = [k for k in route.children if k.path == "/"]
-                if self.parts and self.parts[0] and default_routes:
-                    self.path_routes.append(default_routes[0])
-                    self.path_routes_siblings.append(route.children)
-
-        assert len(self.path_routes) == len(self.path_routes_siblings)
-        self.possible_match = (len(self.path_routes[-1].children) == 0) if self.path_routes else False
-
-    def push(self, path: str):
-        assert self.set_path is not None
-        self.set_path(path)
-
-
-router_context = solara.create_context(Router("", []))
-_location_context = solara.create_context(cast(_LocationBase, _Location("", lambda x: None)))
-
-route_level_context = solara.create_context(0)
-
-
-def use_route_level():
-    route_level = solara.use_context(route_level_context)
-    return route_level
-
-
-def use_router() -> Router:
-    """Returns the current router object.
-
-    See also [Understanding Routing](/documentation/advanced/understanding/routing).
-
-    `use_router` returns the current router object. This is useful to build custom routing.
-
-    the router object contains the following properties/methods:
-
-     * `path` - the current pathname (e.g. `/fruit/banana`)
-     * `parts` - the current pathname split into parts (e.g. `['fruit', 'banana']`)
-     * `search` - the query parameters string (e.g. `color=yellow`).
-     * `push(path: str)` - navigate to path (e.g. `router.push('/fruit/banana')`)
-
-    ## Typical usage:
-
-    ```python
-    import solara
-
-
-    @solara.component
-    def Page():
-        router = solara.use_router()
-
-        def redirect():
-            router.push(f"/documentation/api/routing/use_route")
-
-        solara.Button("Navigate using an event", on_click=redirect)
-    ```
-
-    """
-    return solara.use_context(router_context)
-
-
-def use_route(
-    level=0,
-    peek=False,
-) -> Tuple[Optional[solara.Route], List[solara.Route]]:
-    """Returns (if found) the current route that matches the pathname, or None
-
-    See also [Understanding Routing](/documentation/advanced/understanding/routing).
-
-    `use_route` returns (if found) the current route that matches the pathname, or None. It also returns all resolved routes of that level
-    (i.e. all siblings and itself). This return tuple is useful to build custom navigation (e.g. using tabs or buttons).
-
-
-    Routing starts with declaring a set of `routes` in your app (solara picks up the `routes` variable if it exists,
-    and it should be in the same namespace as `Page`).
-    In the demo below, we declared the following routes.
-
-    ```python
-    routes = [
-        solara.Route(path="/"),
-        solara.Route(
-            path="fruit",
-            component=Fruit,
-            children=[
-                solara.Route(path="/"),
-                solara.Route(path="kiwi"),
-                solara.Route(path="banana"),
-                solara.Route(path="apple"),
-            ],
-        ),
-    ]
-    ```
-
-    Note that all routes are relative, since a component does not know if it is embedded into a larger application, which may also do routing.
-    Therefore you should never use the `route.path` for navigation since the route object has no knowledge of the full url
-    (e.g. `/documentation/api/routing/use_route/fruit/banana`) but only knows its small piece of the pathname (e.g. `banana`)
-
-    Use [`resolve_path`](/documentation/api/routing/resolve_path) to request the full url for navigation,
-        or simply use the `Link` component that can do this for us.
-
-    If the current route has children, any child component that calls `use_route` will return the matched route and its siblings of our children.
-
-
-    ## Arguments
-
-    * `level`: the level of the route to return. 0 is the current route, -1 is the parent route, 1 the child route, etc.
-    * `peek`: if True, the route level is not incremented. This is useful to peek at the next route level without changing the current route level.
-    """
-
-    router = solara.use_context(router_context)
-    route_level = solara.use_context(route_level_context)
-    if not peek:
-        route_level_context.provide(route_level + 1)
-    route_level += level
-    if route_level < len(router.path_routes):
-        return router.path_routes[route_level], router.path_routes_siblings[route_level]
-    else:
-        return None, []
-
-
-def find_route(path: str) -> Optional[solara.Route]:
-    router = solara.get_context(router_context)
-    route_level = min(solara.get_context(route_level_context), len(router.path_routes_siblings) - 1)
-    for route in router.path_routes_siblings[route_level]:
-        if path.startswith(route.path) or (not path and route.path == "/"):
-            return route
-    return None
-
-
-def use_pathname():
-    location_proxy = solara.use_context(_location_context)
-
-    def setter(value):
-        location_proxy.pathname = value
-
-    return location_proxy.pathname, setter
-
-
-def resolve_path(path_or_route: Union[str, solara.Route], level=0) -> str:
-    """Resolve a relative path or a route to an absolute path.
-
-    If the path is a string and starts with a `/'`, it is returned as is.
-
-
-    ## Typical usage:
-
-    ```python
-    ...
-    route_current, routes_current_level = solara.routes()
-    # route_current.path == "banana"
-    path = solara.resolve_path(route_current)
-    # path == "/fruit/banana"
-    path_same = solara.resolve_path("banana")
-    # path_same == path == "/fruit/banana"
-    ...
-    ```
-
-    ## Arguments
-
-     * path_or_route: a path string or a [`solara.Route`](/documentation/api/routing/route) object to resolve.
-
-    ## See also
-
-     * [Multipage](/documentation/advanced/howto/multipage).
-     * [Understanding Routing](/documentation/advanced/understanding/routing).
-
-
-    """
-    router = solara.get_context(router_context)
-    if isinstance(path_or_route, str):
-        path = path_or_route
-        if path.startswith("/"):
-            return path
-        route_level = solara.get_context(route_level_context) + level
-        parts = [*router.parts[:route_level], path]
-        path = "/" + "/".join(parts)
-        if path.startswith("//"):
-            path = path[1:]
-        return path
-    elif isinstance(path_or_route, solara.Route):
-        route: solara.Route = path_or_route
-        path = _resolve_path("/", route, router.routes)
-        if path.startswith("//"):
-            path = path[1:]
-        return path
-
-
-def _resolve_path(prefix: str, findroute: solara.Route, routes: List[solara.Route]):
-    for route in routes:
-        path = (prefix + "/" + route.path) if route.path != "/" else prefix
-        if findroute is route:
-            return path
-        possible_path = _resolve_path(path, findroute=findroute, routes=route.children)
-        if possible_path is not None:
-            return possible_path