solara-ui 1.41.0__py2.py3-none-any.whl → 1.43.0__py2.py3-none-any.whl

solara/components/markdown.py

@@ -4,7 +4,8 @@ import logging
 import textwrap
 import traceback
 import warnings
-from typing import Any, Dict, List, Union, cast
+from typing import Any, Callable, Dict, List, Optional, Union, cast
+import typing
 
 import ipyvuetify as v
 
@@ -16,6 +17,7 @@ try:
     has_pymdownx = True
 except ModuleNotFoundError:
     has_pymdownx = False
+import reacton.core
 
 import solara
 import solara.components.applayout
@@ -30,6 +32,9 @@ else:
     from pygments.formatters import HtmlFormatter
     from pygments.lexers import get_lexer_by_name
 
+if typing.TYPE_CHECKING:
+    import markdown
+
 logger = logging.getLogger(__name__)
 
 html_no_execute_enabled = "<div><i>Solara execution is not enabled</i></div>"
@@ -50,7 +55,7 @@ def ExceptionGuard(children=[]):
             solara.Column(children=children)
 
 
-def _run_solara(code):
+def _run_solara(code, cleanups):
     ast = compile(code, "markdown", "exec")
     local_scope: Dict[Any, Any] = {}
     exec(ast, local_scope)
@@ -63,6 +68,13 @@ def _run_solara(code):
     else:
         raise NameError("No Page or app defined")
     box = v.Html(tag="div")
+
+    rc: reacton.core.RenderContext
+
+    def cleanup():
+        rc.close()
+
+    cleanups.append(cleanup)
     box, rc = solara.render(cast(solara.Element, app), container=box)  # type: ignore
     widget_id = box._model_id
     return (
@@ -231,9 +243,8 @@ module.exports = {
     return template
 
 
-def _highlight(src, language, unsafe_solara_execute, extra, *args, **kwargs):
+def _highlight(src, language, class_name=None, options=None, md=None, unsafe_solara_execute=False, cleanups=None, **kwargs):
     """Highlight a block of code"""
-
     if not has_pygments:
         warnings.warn("Pygments is not installed, code highlighting will not work, use pip install pygments to install it.")
         src_safe = html.escape(src)
@@ -250,7 +261,7 @@ def _highlight(src, language, unsafe_solara_execute, extra, *args, **kwargs):
 
     if run_src_with_solara:
         if unsafe_solara_execute:
-            html_widget = _run_solara(src)
+            html_widget = _run_solara(src, cleanups)
             return src_html + html_widget
         else:
             return src_html + html_no_execute_enabled
@@ -258,6 +269,19 @@ def _highlight(src, language, unsafe_solara_execute, extra, *args, **kwargs):
         return src_html
 
 
+def formatter(unsafe_solara_execute: bool, cleanups: List[Callable[[], None]]):
+    def wrapper(*args, **kwargs):
+        try:
+            kwargs["unsafe_solara_execute"] = unsafe_solara_execute
+            kwargs["cleanups"] = cleanups
+            return _highlight(*args, **kwargs)
+        except Exception as e:
+            logger.exception("Error while highlighting code")
+            raise e
+
+    return wrapper
+
+
 @solara.component
 def MarkdownIt(md_text: str, highlight: List[int] = [], unsafe_solara_execute: bool = False):
     md_text = textwrap.dedent(md_text)
@@ -267,8 +291,10 @@ def MarkdownIt(md_text: str, highlight: List[int] = [], unsafe_solara_execute: b
     from mdit_py_plugins.footnote import footnote_plugin  # noqa: F401
     from mdit_py_plugins.front_matter import front_matter_plugin  # noqa: F401
 
+    cleanups = solara.use_ref(cast(List[Callable[[], None]], []))
+
     def highlight_code(code, name, attrs):
-        return _highlight(code, name, unsafe_solara_execute, attrs)
+        return _highlight(cleanups.current, code, name, unsafe_solara_execute, attrs)
 
     md = MarkdownItMod(
         "js-default",
@@ -281,6 +307,15 @@ def MarkdownIt(md_text: str, highlight: List[int] = [], unsafe_solara_execute: b
     md = md.use(container.container_plugin, name="note")
     html = md.render(md_text)
     hash = hashlib.sha256((html + str(unsafe_solara_execute) + repr(highlight)).encode("utf-8")).hexdigest()
+
+    def cleanup_wrapper():
+        def cleanup():
+            for cleanup in cleanups.current:
+                cleanup()
+
+        return cleanup
+
+    solara.use_effect(cleanup_wrapper)
     return v.VuetifyTemplate.element(template=_markdown_template(html)).key(hash)
 
 
@@ -293,7 +328,7 @@ def _no_deep_copy_emojione(options, md):
 
 
 @solara.component
-def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict, None] = None):
+def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict, None] = None, md_parser: Optional["markdown.Markdown"] = None):
     """Renders markdown text
 
     Renders markdown using https://python-markdown.github.io/
@@ -333,21 +368,19 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
      * `unsafe_solara_execute`: If True, code marked with language "solara" will be executed. This is potentially unsafe
         if the markdown text can come from user input and should only be used for trusted markdown.
      * `style`: A string or dict of css styles to apply to the rendered markdown.
+     * `md_parser`: A markdown object to use for rendering. If not provided, a markdown object will be created.
 
     """
     import markdown
 
     md_text = textwrap.dedent(md_text)
     style = solara.util._flatten_style(style)
+    cleanups = solara.use_ref(cast(List[Callable[[], None]], []))
 
     def make_markdown_object():
-        def highlight(src, language, *args, **kwargs):
-            try:
-                return _highlight(src, language, unsafe_solara_execute, *args, **kwargs)
-            except Exception as e:
-                logger.exception("Error highlighting code: %s", src)
-                return repr(e)
-
+        if md_parser is not None:
+            # we won't use the use_memo
+            return None
         if has_pymdownx:
             return markdown.Markdown(  # type: ignore
                 extensions=[
@@ -371,7 +404,7 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
                             {
                                 "name": "solara",
                                 "class": "",
-                                "format": highlight,
+                                "format": formatter(unsafe_solara_execute, cleanups=cleanups.current),
                             },
                         ],
                     },
@@ -388,8 +421,20 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
                 ],
             )
 
-    md = solara.use_memo(make_markdown_object, dependencies=[unsafe_solara_execute])
-    html = md.convert(md_text)
+    md_self = solara.use_memo(make_markdown_object, dependencies=[unsafe_solara_execute])
+    if md_parser is None:
+        assert md_self is not None
+        md_parser = md_self
+    html = md_parser.convert(md_text)
+
+    def cleanup_wrapper():
+        def cleanup():
+            for cleanup in cleanups.current:
+                cleanup()
+
+        return cleanup
+
+    solara.use_effect(cleanup_wrapper, [])
     # if we update the template value, the whole vue tree will rerender (ipvue/ipyvuetify issue)
     # however, using the hash we simply generate a new widget each time
     hash = hashlib.sha256((html + str(unsafe_solara_execute)).encode("utf-8")).hexdigest()

solara/components/misc.py

@@ -136,7 +136,7 @@ def HTML(tag="div", unsafe_innerHTML=None, style: str = None, classes: List[str]
 
 @solara.component
 def VBox(children=[], grow=True, align_items="stretch", classes: List[str] = []):
-    """Deprecated. Use `Row` instead."""
+    """Deprecated. Use `Column` instead."""
     style = f"flex-direction: column; align-items: {align_items};"
     if grow:
         style += "flex-grow: 1;"
@@ -146,7 +146,7 @@ def VBox(children=[], grow=True, align_items="stretch", classes: List[str] = [])
 
 @solara.component
 def HBox(children=[], grow=True, align_items="stretch", classes: List[str] = []):
-    """Deprecated. Use `Column` instead."""
+    """Deprecated. Use `Row` instead."""
     style = f"flex-direction: row; align-items: {align_items}; "
     if grow:
         style += "flex-grow: 1;"

solara/components/spinner-solara.vue

@@ -5,10 +5,10 @@
             xmlns:svgjs="http://svgjs.com/svgjs" :width="size" :height="size" viewBox="0 0 65 65" fill="none">
             <path id="sun-spinner1" style="transform-origin: center;"
                 d="M57.11 30.64L61.47 17.87L48.7 13.51L42.76 1.39999L30.65 7.34999L17.87 2.97999L13.51 15.75L1.40002 21.7L7.35002 33.81L2.99002 46.58L15.76 50.94L21.71 63.06L33.82 57.11L46.59 61.47L50.95 48.7L63.06 42.75L57.11 30.64ZM54.26 34.39L34.39 54.26C33.19 55.46 31.25 55.46 30.05 54.26L10.2 34.4C9.00002 33.2 9.00002 31.26 10.2 30.07L30.06 10.2C31.26 8.99999 33.2 8.99999 34.4 10.2L54.27 30.07C55.47 31.27 55.47 33.21 54.27 34.4L54.26 34.39Z"
-                fill="#FFCF64"></path>
+                :fill="color_back"></path>
             <path id="sun-spinner2" style="transform-origin: center;"
                 d="M53.62 19.42L51.65 6.07L38.3 8.04L27.46 0L19.42 10.84L6.07 12.82L8.04 26.17L0 37L10.84 45.04L12.81 58.39L26.16 56.42L37 64.46L45.04 53.62L58.39 51.64L56.42 38.29L64.46 27.45L53.62 19.4V19.42ZM52.8 24.06L44.24 50.82C43.72 52.43 42 53.32 40.39 52.81L13.63 44.25C12.02 43.74 11.13 42.01 11.64 40.4L20.21 13.64C20.72 12.03 22.45 11.14 24.06 11.65L50.82 20.21C52.43 20.72 53.32 22.45 52.81 24.06H52.8Z"
-                fill="#FF8C3E"></path>
+                :fill="color_front"></path>
         </svg>
     </div>
 </template>

solara/components/spinner.py

@@ -8,12 +8,15 @@ class SpinnerSolaraWidget(ipyvue.VueTemplate):
     template_file = (__file__, "spinner-solara.vue")
 
     size = traitlets.Unicode("64px").tag(sync=True)
+    color_back = traitlets.Unicode("#FFCF64").tag(sync=True)
+    color_front = traitlets.Unicode("#FF8C3E").tag(sync=True)
 
 
 @solara.component
-def SpinnerSolara(size="64px"):
+def SpinnerSolara(size="64px", color_back="#FFCF64", color_front="#FF8C3E"):
     """Spinner component with the Solara logo to indicate the app is busy.
 
+    ## Examples
     ### Basic example
 
     ```solara
@@ -24,7 +27,19 @@ def SpinnerSolara(size="64px"):
         solara.SpinnerSolara(size="100px")
     ```
 
+    ## Changing the colors
+    ```solara
+    import solara
+
+    @solara.component
+    def Page():
+        solara.SpinnerSolara(size="100px", color_back="Grey", color_front="Lime")
+    ```
+
+
     ## Arguments
      * `size`: Size of the spinner.
+     * `color_back`: Color of the spinner in the background.
+     * `color_front`: Color of the spinner in the foreground.
     """
-    return SpinnerSolaraWidget.element(size=size)
+    return SpinnerSolaraWidget.element(size=size, color_back=color_back, color_front=color_front)

solara/hooks/use_reactive.py

@@ -1,4 +1,4 @@
-from typing import Callable, Optional, TypeVar, Union
+from typing import Any, Callable, Optional, TypeVar, Union
 
 import solara
 
@@ -8,6 +8,7 @@ T = TypeVar("T")
 def use_reactive(
     value: Union[T, solara.Reactive[T]],
     on_change: Optional[Callable[[T], None]] = None,
+    equals: Callable[[Any, Any], bool] = solara.util.equals_extra,
 ) -> solara.Reactive[T]:
     """Creates a reactive variable with the a local component scope.
 
@@ -44,6 +45,12 @@ def use_reactive(
      * on_change (Optional[Callable[[T], None]]): An optional callback function
             that will be called when the reactive variable's value changes.
 
+     * equals: A function that returns True if two values are considered equal, and False otherwise.
+            The default function is `solara.util.equals`, which performs a deep comparison of the two values
+            and is more forgiving than the default `==` operator.
+            You can provide a custom function if you need to define a different notion of equality.
+
+
     Returns:
         solara.Reactive[T]: A reactive variable with the specified initial value
             or the provided reactive variable.

solara/lab/components/__init__.py

@@ -1,6 +1,7 @@
 from .chat import ChatBox, ChatInput, ChatMessage  # noqa: F401
 from .confirmation_dialog import ConfirmationDialog  # noqa: F401
 from .input_date import InputDate, InputDateRange  # noqa: F401
+from .input_time import InputTime as InputTime
 from .menu import ClickMenu, ContextMenu, Menu  # noqa: F401 F403
 from .tabs import Tab, Tabs  # noqa: F401
 from .theming import ThemeToggle, theme, use_dark_effective  # noqa: F401

solara/lab/components/chat.py

@@ -43,7 +43,7 @@ def ChatBox(
 
 @solara.component
 def ChatInput(
-    send_callback: Optional[Callable] = None,
+    send_callback: Optional[Callable[[str], None]] = None,
     disabled: bool = False,
     style: Optional[Union[str, Dict[str, str]]] = None,
     input_text_style: Optional[Union[str, Dict[str, str]]] = None,
@@ -55,7 +55,7 @@ def ChatInput(
 
     # Arguments
 
-    * `send_callback`: A callback function for when the user presses enter or clicks the send button.
+    * `send_callback`: A callback function for when the user presses enter or clicks the send button taking the message as an argument.
     * `disabled`: Whether the input should be disabled. Useful for disabling sending further messages while a chatbot is replying,
         among other things.
     * `style`: CSS styles to apply to the `solara.Row` containing the input field and submit button. Either a string or a dictionary.
@@ -98,7 +98,7 @@ def ChatInput(
 
 @solara.component
 def ChatMessage(
-    children: Union[List[solara.Element], str],
+    children: Union[List[solara.Element], str] = [],
     user: bool = False,
     avatar: Union[solara.Element, str, Literal[False], None] = None,
     name: Optional[str] = None,

solara/lab/components/input_time.py

@@ -0,0 +1,133 @@
+import datetime as dt
+from typing import Callable, Dict, List, Optional, Union
+
+import solara
+import solara.lab
+from solara.lab.components.input_date import use_close_menu
+from solara.components.input import _use_input_type
+
+
+@solara.component
+def InputTime(
+    value: Union[solara.Reactive[Optional[dt.time]], Optional[dt.time]],
+    on_value: Optional[Callable[[Optional[dt.time]], None]] = None,
+    label: str = "Pick a time",
+    children: List[solara.Element] = [],
+    open_value: Union[solara.Reactive[bool], bool] = False,
+    on_open_value: Optional[Callable[[bool], None]] = None,
+    optional: bool = False,
+    twelve_hour_clock: bool = False,
+    use_seconds: bool = False,
+    allowed_minutes: Optional[List[int]] = None,
+    style: Optional[Union[str, Dict[str, str]]] = None,
+    classes: Optional[List[str]] = None,
+):
+    """
+    Show a textfield, which when clicked, opens a timepicker. The input time should be of type `datetime.time`.
+
+    ## Basic Example
+
+    ```solara {pycafe-link}
+    import solara
+    import solara.lab
+    import datetime as dt
+
+
+    @solara.component
+    def Page():
+        time = solara.use_reactive(dt.time(12, 0))
+
+        solara.lab.InputTime(time, allowed_minutes=[0, 15, 30, 45])
+        solara.Text(str(time.value))
+    ```
+
+    ## Arguments
+
+    * value: Reactive variable of type `datetime.time`, or `None`. This time is selected the first time the component is rendered.
+    * on_value: a callback function for when value changes. The callback function receives the new value as an argument.
+    * label: Text used to label the text field that triggers the timepicker.
+    * children: List of Elements to be rendered under the timepicker. If empty, a close button is rendered.
+    * open_value: Controls and communicates the state of the timepicker. If True, the timepicker is open. If False, the timepicker is closed.
+    Intended to be used in conjunction with a custom set of controls to close the timepicker.
+    * on_open_value: a callback function for when open_value changes. Also receives the new value as an argument.
+    * optional: Determines whether to show an error when value is `None`. If `True`, no error is shown.
+    * twelve_hour_clock: If `True`, the timepicker will display in 12-hour format. If `False`, the timepicker will display in 24-hour format.
+    * use_seconds: If `True`, the timepicker will allow input of seconds.
+    * allowed_minutes: List of allowed minutes for the timepicker. Restricts the input to specific minute intervals.
+    * style: CSS style to apply to the text field. Either a string or a dictionary of CSS properties (i.e. `{"property": "value"}`).
+    * classes: List of CSS classes to apply to the text field.
+    """
+    time_format_internal = f"%H:%M{':%S' if use_seconds else ''}"
+    time_format_display = f"%H:%M{':%S' if use_seconds else ''}"
+    if twelve_hour_clock:
+        time_format_display = f"%I:%M{':%S' if use_seconds else ''} %p"
+    value_reactive = solara.use_reactive(value, on_value)  # type: ignore
+    del value, on_value
+    timepicker_is_open = solara.use_reactive(open_value, on_open_value)  # type: ignore
+    del open_value, on_open_value
+
+    def set_time_typed_cast(value: Optional[str]):
+        if value:
+            try:
+                time_value = dt.datetime.strptime(value, time_format_display).time()
+                return time_value
+            except ValueError:
+                raise ValueError(f"Time {value} does not match format {time_format_display.replace('%', '')}")
+        elif optional:
+            return None
+        else:
+            raise ValueError("Time cannot be empty")
+
+    def time_to_str(time: Optional[dt.time]) -> str:
+        if time is not None:
+            return time.strftime(time_format_display)
+        return ""
+
+    def set_time_cast(new_value: Optional[str]):
+        if new_value:
+            time_value = dt.datetime.strptime(new_value, time_format_internal).time()
+            value_reactive.value = time_value
+
+    def standard_strfy(time: Optional[dt.time]):
+        if time is None:
+            return None
+        else:
+            return time.strftime(time_format_internal)
+
+    time_standard_str = standard_strfy(value_reactive.value)
+
+    style_flat = solara.util._flatten_style(style)
+
+    internal_value, error_message, set_value_cast = _use_input_type(value_reactive, set_time_typed_cast, time_to_str)
+
+    if error_message:
+        label += f" ({error_message})"
+    input = solara.v.TextField(
+        label=label,
+        v_model=internal_value,
+        on_v_model=set_value_cast,
+        append_icon="mdi-clock",
+        error=bool(error_message),
+        style_="min-width: 290px;" + style_flat,
+        class_=", ".join(classes) if classes else "",
+    )
+
+    use_close_menu(input, timepicker_is_open)
+
+    with solara.lab.Menu(
+        activator=input,
+        close_on_content_click=False,
+        open_value=timepicker_is_open,
+        use_activator_width=False,
+    ):
+        with solara.v.TimePicker(
+            ampm_in_title=twelve_hour_clock,
+            v_model=time_standard_str,
+            on_v_model=set_time_cast,
+            format="24hr" if not twelve_hour_clock else "ampm",
+            allowed_minutes=allowed_minutes,
+            use_seconds=use_seconds,
+            style_="width: 100%;",
+        ):
+            if len(children) > 0:
+                solara.display(*children)

solara/lab/hooks/dataframe.py

@@ -1 +1,2 @@
 from ..utils.dataframe import df_columns as use_df_column_names  # noqa: F401
+from ..utils.dataframe import df_row_names as df_row_names

solara/lab/utils/dataframe.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Union
 
 
 def get_pandas_major():
@@ -28,6 +28,16 @@ def df_columns(df) -> List[str]:
         raise TypeError(f"{type(df)} not supported")
 
 
+def df_row_names(df) -> List[Union[int, str]]:
+    """Return a list of row names from a dataframe."""
+    if df_type(df) == "vaex" or df_type(df) == "polars":
+        return list(range(df_len(df)))
+    elif df_type(df) == "pandas":
+        return df.index.tolist()
+    else:
+        raise TypeError(f"{type(df)} not supported")
+
+
 def df_slice(df, start: int, stop: int):
     """Return a subset of rows from a dataframe."""
     if df_type(df) == "pandas":

solara/reactive.py

@@ -1,13 +1,14 @@
-from typing import TypeVar
+from typing import Any, Callable, TypeVar
 
 from solara.toestand import Reactive
+import solara.util
 
 __all__ = ["reactive", "Reactive"]
 
 T = TypeVar("T")
 
 
-def reactive(value: T) -> Reactive[T]:
+def reactive(value: T, equals: Callable[[Any, Any], bool] = solara.util.equals_extra) -> 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
@@ -35,6 +36,11 @@ def reactive(value: T) -> Reactive[T]:
 
     Args:
         value (T): The initial value of the reactive variable.
+        equals: A function that returns True if two values are considered equal, and False otherwise.
+            The default function is `solara.util.equals`, which performs a deep comparison of the two values
+            and is more forgiving than the default `==` operator.
+            You can provide a custom function if you need to define a different notion of equality.
+
 
     Returns:
         Reactive[T]: A new Reactive object with the specified initial value.
@@ -90,4 +96,4 @@ def reactive(value: T) -> Reactive[T]:
     Whenever the counter value changes, `CounterDisplay` automatically updates to display the new value.
 
     """
-    return Reactive(value)
+    return Reactive(value, equals=equals)