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

solara/__init__.py

@@ -1,6 +1,6 @@
 """Build webapps using IPywidgets"""
 
-__version__ = "1.42.0"
+__version__ = "1.43.0"
 github_url = "https://github.com/widgetti/solara"
 git_branch = "master"
 

solara/__main__.py

@@ -21,6 +21,8 @@ import solara.server.threaded
 
 from .server import telemetry
 
+print_mutex = threading.Lock()
+
 try:
     from solara_enterprise.ssg import ssg_crawl
 except ImportError:
@@ -75,13 +77,15 @@ def _check_version():
     import requests
 
     try:
-        response = requests.get("https://pypi.org/pypi/solara/json")
+        response = requests.get("https://pypi.org/pypi/solara/json", timeout=0.5)
         latest_version = response.json()["info"]["version"]
     except:  # noqa: E722
+        # in case of a firewall, or timeout, we just abort
         return
     if latest_version != solara.__version__:
-        print(f"New version of Solara available: {latest_version}. You have {solara.__version__}. Please upgrade using:")  # noqa: T201
-        print(f'\t$ pip install "solara=={latest_version}"')  # noqa: T201
+        with print_mutex:
+            print(f"New version of Solara available: {latest_version}. You have {solara.__version__}. Please upgrade using:")  # noqa: T201
+            print(f'\t$ pip install "solara=={latest_version}"')  # noqa: T201
 
 
 def find_all_packages_paths():
@@ -306,7 +310,7 @@ def run(
         print("solara: --reload is deprecated, use --auto-restart/-a instead", file=sys.stderr)  # noqa: T201
         auto_restart = reload
     if check_version:
-        _check_version()
+        threading.Thread(target=_check_version, daemon=True).run()
 
     # uvicorn calls it reload, we call it auto restart
     reload = auto_restart
@@ -390,7 +394,8 @@ def run(
     if open and not qt:
         threading.Thread(target=open_browser, daemon=True).start()
 
-    rich.print(f"Solara server is starting at {url}")
+    with print_mutex:
+        rich.print(f"Solara server is starting at {url}")
 
     if log_level is not None:
         LOGGING_CONFIG["loggers"]["solara"]["level"] = log_level.upper()

solara/_stores.py

@@ -11,12 +11,16 @@ class _PublicValueNotSet:
     pass
 
 
+class _SetValueNotSet:
+    pass
+
+
 @dataclasses.dataclass
 class StoreValue(Generic[S]):
     private: S  # the internal private value, should never be mutated
     public: Union[S, _PublicValueNotSet]  # this is the value that is exposed in .get(), it is a deep copy of private
     get_traceback: Optional[inspect.Traceback]
-    set_value: Optional[S]  # the value that was set using .set(..), we deepcopy this to set private
+    set_value: Union[S, _SetValueNotSet]  # the value that was set using .set(..), we deepcopy this to set private
     set_traceback: Optional[inspect.Traceback]
 
 
@@ -79,7 +83,7 @@ class MutateDetectorStore(ValueBase[S]):
                     code = "<No code context available>"
                 msg += f"The last value was read in the following code:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
             raise ValueError(msg)
-        elif store_value.set_value is not None and not self.equals(store_value.set_value, store_value.private):
+        elif not isinstance(store_value.set_value, _SetValueNotSet) and not self.equals(store_value.set_value, store_value.private):
             tb = store_value.set_traceback
             msg = f"""Reactive variable was set with a value of {store_value.private!r}, but was later mutated mutated to {store_value.set_value!r}.
 
@@ -161,11 +165,11 @@ reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
     def subscribe(self, listener: Callable[[S], None], scope: Optional[ContextManager] = None):
         def listener_wrapper(new: StoreValue[S], previous: StoreValue[S]):
             self._ensure_public_exists()
-            assert new.public is not None
-            assert previous.public is not None
-            previous_value = previous.set_value if previous.set_value is not None else previous.private
+            assert not isinstance(new.public, _PublicValueNotSet)
+            assert not isinstance(previous.public, _PublicValueNotSet)
+            previous_value = previous.set_value if not isinstance(previous.set_value, _SetValueNotSet) else previous.private
             new_value = new.set_value
-            assert new_value is not None
+            assert not isinstance(new_value, _SetValueNotSet)
             if not self.equals(new_value, previous_value):
                 listener(new_value)
 
@@ -174,11 +178,11 @@ reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
     def subscribe_change(self, listener: Callable[[S, S], None], scope: Optional[ContextManager] = None):
         def listener_wrapper(new: StoreValue[S], previous: StoreValue[S]):
             self._ensure_public_exists()
-            assert new.public is not None
-            assert previous.public is not None
-            previous_value = previous.set_value if previous.set_value is not None else previous.private
+            assert not isinstance(new.public, _PublicValueNotSet)
+            assert not isinstance(previous.public, _PublicValueNotSet)
+            previous_value = previous.set_value if not isinstance(previous.set_value, _SetValueNotSet) else previous.private
             new_value = new.set_value
-            assert new_value is not None
+            assert not isinstance(new_value, _SetValueNotSet)
             if not self.equals(new_value, previous_value):
                 listener(new_value, previous_value)
 

solara/components/__init__.py

@@ -57,4 +57,21 @@ from .progress import ProgressLinear  # noqa: F401 F403
 from .component_vue import _component_vue, component_vue  # noqa: F401 F403
 import reacton.core
 
-reacton.core._default_container = Column  # noqa: F405
+try:
+    from reacton import Fragment as Fragment  # type: ignore
+except ImportError:
+    pass
+
+import logging
+from ..settings import main
+
+_container = None
+
+if main.default_container in globals():
+    _container = globals()[main.default_container]
+else:
+    logger = logging.getLogger("solara.components")
+    logger.warning(f"Default container {main.default_container} not found in solara.components. Defaulting to Column.")
+
+# TODO: When Solara 2.0 releases Column should be replaced with Fragment
+reacton.core._default_container = _container or Column  # noqa: F405

solara/components/datatable.py

@@ -10,14 +10,14 @@ import solara
 import solara.hooks.dataframe
 import solara.lab
 import traitlets
-from solara.lab.hooks.dataframe import use_df_column_names
+from solara.lab.hooks.dataframe import use_df_column_names, df_row_names
 from solara.lab.utils.dataframe import df_len, df_records, df_slice
 
 from .. import CellAction, ColumnAction
 
 
 def _ensure_dict(d):
-    if dataclasses.is_dataclass(d):
+    if dataclasses.is_dataclass(d) and not isinstance(d, type):  # is_dataclass also returns True for dataclass type, rather than instance
         return dataclasses.asdict(d)
     return d
 
@@ -100,12 +100,12 @@ def DataTable(
     i2 = min(total_length, (page + 1) * items_per_page)
 
     columns = use_df_column_names(df)
-
+    rows = df_row_names(df)
     items = []
     dfs = df_slice(df, i1, i2)
     records = df_records(dfs)
     for i in range(i2 - i1):
-        item = {"__row__": i + i1}  # special key for the row number
+        item = {"__row__": format(dfs, columns, i + 1, rows[i + i1])}  # special key for the row number
         for column in columns:
             item[column] = format(dfs, column, i + i1, records[i][column])
         items.append(item)

solara/components/input.py

@@ -373,6 +373,10 @@ def _use_input_type(
         error_message = str(e.args[0])
 
     def sync_back_input_value():
+        # Make sure we update string_value when the effect is rerun,
+        # Since the parsing & stringigying functions might have changed
+        set_string_value(stringify(reactive_value.value) if reactive_value.value is not None else None)
+
         def on_external_value_change(new_value: Optional[T]):
             new_string_value = stringify(new_value)
             try:
@@ -386,7 +390,7 @@ def _use_input_type(
 
         return reactive_value.subscribe(on_external_value_change)
 
-    solara.use_effect(sync_back_input_value, [reactive_value])
+    solara.use_effect(sync_back_input_value, [reactive_value, parse, stringify])
 
     return string_value, error_message, set_string_value
 

solara/components/markdown.py

@@ -1,11 +1,10 @@
-import functools
 import hashlib
 import html
 import logging
 import textwrap
 import traceback
 import warnings
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, Callable, Dict, List, Optional, Union, cast
 import typing
 
 import ipyvuetify as v
@@ -18,6 +17,7 @@ try:
     has_pymdownx = True
 except ModuleNotFoundError:
     has_pymdownx = False
+import reacton.core
 
 import solara
 import solara.components.applayout
@@ -55,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)
@@ -68,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 (
@@ -236,9 +243,8 @@ module.exports = {
     return template
 
 
-def _highlight(src, language, unsafe_solara_execute, *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)
@@ -255,7 +261,7 @@ def _highlight(src, language, unsafe_solara_execute, *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
@@ -263,8 +269,17 @@ def _highlight(src, language, unsafe_solara_execute, *args, **kwargs):
         return src_html
 
 
-def formatter(unsafe_solara_execute: bool):
-    return functools.partial(_highlight, unsafe_solara_execute=unsafe_solara_execute)
+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
@@ -276,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",
@@ -290,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)
 
 
@@ -349,6 +375,7 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
 
     md_text = textwrap.dedent(md_text)
     style = solara.util._flatten_style(style)
+    cleanups = solara.use_ref(cast(List[Callable[[], None]], []))
 
     def make_markdown_object():
         if md_parser is not None:
@@ -377,7 +404,7 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
                             {
                                 "name": "solara",
                                 "class": "",
-                                "format": formatter(unsafe_solara_execute),
+                                "format": formatter(unsafe_solara_execute, cleanups=cleanups.current),
                             },
                         ],
                     },
@@ -399,6 +426,15 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
         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/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":