solara-ui 1.31.0__py2.py3-none-any.whl

solara/lab/utils/dataframe.py

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

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

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

@@ -0,0 +1,46 @@
+from types import FrameType, ModuleType
+from typing import Callable, List, NamedTuple, Optional
+from pathlib import Path
+import inspect
+
+
+class _on_kernel_callback_entry(NamedTuple):
+    callback: Callable[[], Optional[Callable[[], None]]]
+    callpoint: Optional[Path]
+    module: Optional[ModuleType]
+    cleanup: Callable[[], None]
+
+
+_on_kernel_start_callbacks: List[_on_kernel_callback_entry] = []
+
+
+def _find_root_module_frame() -> Optional[FrameType]:
+    # basically the module where the call stack origined from
+    current_frame = inspect.currentframe()
+    root_module_frame = None
+
+    while current_frame is not None:
+        if current_frame.f_code.co_name == "<module>":
+            root_module_frame = current_frame
+            break
+        current_frame = current_frame.f_back
+
+    return root_module_frame
+
+
+def on_kernel_start(f: Callable[[], Optional[Callable[[], None]]]) -> Callable[[], None]:
+    root = _find_root_module_frame()
+    path: Optional[Path] = None
+    module: Optional[ModuleType] = None
+    if root is not None:
+        path_str = inspect.getsourcefile(root)
+        module = inspect.getmodule(root)
+        if path_str is not None:
+            path = Path(path_str)
+
+    def cleanup():
+        return _on_kernel_start_callbacks.remove(kce)
+
+    kce = _on_kernel_callback_entry(f, path, module, cleanup)
+    _on_kernel_start_callbacks.append(kce)
+    return cleanup

solara/minisettings.py

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

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