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

solara/lab/components/chat.py

@@ -43,9 +43,12 @@ def ChatBox(
 
 @solara.component
 def ChatInput(
-    send_callback: Optional[Callable] = None,
+    send_callback: Optional[Callable[[str], None]] = None,
     disabled: bool = False,
+    disabled_input: bool = False,
+    disabled_send: bool = False,
     style: Optional[Union[str, Dict[str, str]]] = None,
+    autofocus: bool = False,
     input_text_style: Optional[Union[str, Dict[str, str]]] = None,
     classes: List[str] = [],
     input_text_classes: List[str] = [],
@@ -55,10 +58,12 @@ def ChatInput(
 
     # Arguments
 
-    * `send_callback`: A callback function for when the user presses enter or clicks the send button.
-    * `disabled`: Whether the input should be disabled. Useful for disabling sending further messages while a chatbot is replying,
-        among other things.
+    * `send_callback`: A callback function for when the user presses enter or clicks the send button taking the message as an argument.
+    * `disabled`: disable both input and send.
+    * `disabled_input`: Whether the input should be disabled. Useful for disabling messages while a chatbot is replying.
+    * `disabled_send`: Whether the send button should be disabled. Useful for disabling sending further messages while a chatbot is replying.
     * `style`: CSS styles to apply to the `solara.Row` containing the input field and submit button. Either a string or a dictionary.
+    * `autofocus`: Determines if a component is to be autofocused or not (Default is False). Autofocus will occur during page load and only one component per page can have autofocus active.
     * `input_text_style`: CSS styles to apply to the `InputText` part of the component. Either a string or a dictionary.
     * `classes`: A list of CSS classes to apply to the component. Also applied to the container.
     * `input_text_classes`: A list of CSS classes to apply to the `InputText` part of the component.
@@ -84,21 +89,22 @@ def ChatInput(
             rounded=True,
             filled=True,
             hide_details=True,
+            autofocus=autofocus,
             style_="flex-grow: 1;" + input_text_style_flat,
-            disabled=disabled,
+            disabled=disabled or disabled_input,
             class_=" ".join(input_text_classes),
         )
 
         use_change(message_input, send, update_events=["keyup.enter"])
 
-        button = solara.v.Btn(color="primary", icon=True, children=[solara.v.Icon(children=["mdi-send"])], disabled=message == "")
+        button = solara.v.Btn(color="primary", icon=True, children=[solara.v.Icon(children=["mdi-send"])], disabled=message == "" or disabled or disabled_send)
 
         use_change(button, send, update_events=["click"])
 
 
 @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,
@@ -197,12 +203,12 @@ def ChatMessage(
             .chat-message-{msg_uuid}.left{{
                     border-top-left-radius: 0;
                     background-color:var(--color);
-                    { "margin-left: 10px !important;" if notch else ""}
+                    {"margin-left: 10px !important;" if notch else ""}
             }}
             .chat-message-{msg_uuid}.right{{
                     border-top-right-radius: 0;
                     background-color:var(--color);
-                    { "margin-right: 10px !important;" if notch else ""}
+                    {"margin-right: 10px !important;" if notch else ""}
             }}
             {extra_styles}
             """

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/server/app.py

@@ -7,6 +7,7 @@ import sys
 import threading
 import traceback
 import warnings
+import weakref
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, cast
@@ -62,6 +63,36 @@ class AppScript:
         else:
             self.name = name
         self.path: Path = Path(self.name).resolve()
+        if self.path.is_dir():
+            self.type = AppType.DIRECTORY
+            # resolve the directory, because Path("file").parent.parent == "." != ".."
+            self.directory = self.path.resolve()
+        elif self.name.endswith(".py"):
+            self.type = AppType.SCRIPT
+            self.directory = self.path.parent.resolve()
+        elif self.name.endswith(".ipynb"):
+            self.type = AppType.NOTEBOOK
+            self.directory = self.path.parent.resolve()
+        else:
+            self.type = AppType.MODULE
+            try:
+                spec = importlib.util.find_spec(self.name)
+            except ValueError:
+                if self.name not in sys.modules:
+                    raise ImportError(f"Module {self.name} not found")
+                spec = importlib.util.spec_from_file_location(self.name, sys.modules[self.name].__file__)
+            if spec is None:
+                raise ImportError(f"Module {self.name} cannot be found")
+            assert spec is not None
+            if spec.origin is None:
+                raise ImportError(f"Module {self.name} cannot be found, or is a namespace package")
+            assert spec.origin is not None
+            self.path = Path(spec.origin)
+            self.directory = self.path.parent
+        self._initialized = False
+        self._lock = threading.Lock()
+
+    def init(self):
         try:
             context = kernel_context.get_current_context()
         except RuntimeError:
@@ -84,6 +115,7 @@ class AppScript:
                 package_root_path = Path(mod.__file__).parent
                 reload.reloader.root_path = package_root_path
         dummy_kernel_context.close()
+        self._initialized = True
 
     def _execute(self):
         logger.info("Executing %s", self.name)
@@ -97,10 +129,8 @@ class AppScript:
                 if working_directory not in sys.path:
                     sys.path.insert(0, working_directory)
 
-        if self.path.is_dir():
-            self.type = AppType.DIRECTORY
+        if self.type == AppType.DIRECTORY:
             # resolve the directory, because Path("file").parent.parent == "." != ".."
-            self.directory = self.path.resolve()
             routes = solara.generate_routes_directory(self.path)
 
             if any(name for name in sys.modules.keys() if name.startswith(self.name)):
@@ -110,45 +140,26 @@ class AppScript:
                     "can avoid this ambiguity."
                 )
 
-        elif self.name.endswith(".py"):
-            self.type = AppType.SCRIPT
+        elif self.type == AppType.SCRIPT:
             add_path()
             # manually add the script to the watcher
             reload.reloader.watcher.add_file(self.path)
-            self.directory = self.path.parent.resolve()
             initial_namespace = {
                 "__name__": "__main__",
             }
             with reload.reloader.watch():
                 routes = [solara.autorouting._generate_route_path(self.path, first=True, initial_namespace=initial_namespace)]
-        elif self.name.endswith(".ipynb"):
-            self.type = AppType.NOTEBOOK
+        elif self.type == AppType.NOTEBOOK:
             add_path()
             # manually add the notebook to the watcher
             reload.reloader.watcher.add_file(self.path)
-            self.directory = self.path.parent.resolve()
             with reload.reloader.watch():
                 routes = [solara.autorouting._generate_route_path(self.path, first=True)]
         else:
             # the module itself will be added by reloader
             # automatically
-            with reload.reloader.watch():
+            with kernel_context.without_context(), reload.reloader.watch():
                 self.type = AppType.MODULE
-                try:
-                    spec = importlib.util.find_spec(self.name)
-                except ValueError:
-                    if self.name not in sys.modules:
-                        raise ImportError(f"Module {self.name} not found")
-                    spec = importlib.util.spec_from_file_location(self.name, sys.modules[self.name].__file__)
-                if spec is None:
-                    raise ImportError(f"Module {self.name} cannot be found")
-                assert spec is not None
-                if spec.origin is None:
-                    raise ImportError(f"Module {self.name} cannot be found, or is a namespace package")
-                assert spec.origin is not None
-                self.path = Path(spec.origin)
-                self.directory = self.path.parent
-
                 mod = importlib.import_module(self.name)
                 routes = solara.generate_routes(mod)
 
@@ -213,7 +224,14 @@ class AppScript:
         for context in context_values:
             context.close()
 
+    def check(self):
+        if not self._initialized:
+            with self._lock:
+                if not self._initialized:
+                    self.init()
+
     def run(self):
+        self.check()
         if reload.reloader.requires_reload or self._first_execute_app is None:
             with thread_lock:
                 if reload.reloader.requires_reload or self._first_execute_app is None:
@@ -420,6 +438,9 @@ def solara_comm_target(comm, msg_first):
 
     def on_msg(msg):
         nonlocal app
+        comm = comm_ref()
+        assert comm is not None
+        context = kernel_context.get_current_context()
         data = msg["content"]["data"]
         method = data["method"]
         if method == "run":
@@ -435,7 +456,12 @@ def solara_comm_target(comm, msg_first):
             themes = args.get("themes")
             dark = args.get("dark")
             load_themes(themes, dark)
-            load_app_widget(None, app, path)
+            try:
+                load_app_widget(None, app, path)
+            except Exception as e:
+                msg = f"Error loading app: from path {path} and app {app_name}"
+                logger.exception(msg)
+                raise RuntimeError(msg) from e
             comm.send({"method": "finished", "widget_id": context.container._model_id})
         elif method == "app-status":
             context = kernel_context.get_current_context()
@@ -464,9 +490,10 @@ def solara_comm_target(comm, msg_first):
         else:
             logger.error("Unknown comm method called on solara.control comm: %s", method)
 
-    comm.on_msg(on_msg)
-
     def reload():
+        comm = comm_ref()
+        assert comm is not None
+        context = kernel_context.get_current_context()
         # we don't reload the app ourself, we send a message to the client
         # this ensures that we don't run code of any client that for some reason is connected
         # but not working anymore. And it indirectly passes a message from the current thread
@@ -474,8 +501,11 @@ def solara_comm_target(comm, msg_first):
         logger.debug(f"Send reload to client: {context.id}")
         comm.send({"method": "reload"})
 
-    context = kernel_context.get_current_context()
-    context.reload = reload
+    comm.on_msg(on_msg)
+    comm_ref = weakref.ref(comm)
+    del comm
+
+    kernel_context.get_current_context().reload = reload
 
 
 def register_solara_comm_target(kernel: Kernel):
@@ -489,3 +519,9 @@ patch.patch()
 if "SOLARA_APP" in os.environ:
     with pdb_guard():
         apps["__default__"] = AppScript(os.environ.get("SOLARA_APP", "solara.website.pages:Page"))
+
+
+@solara.util.once
+def ensure_apps_initialized():
+    for app in apps.values():
+        app.init()

solara/server/flask.py

@@ -65,11 +65,17 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
 
     def send_text(self, data: str) -> None:
         with self.lock:
-            self.ws.send(data)
+            try:
+                self.ws.send(data)
+            except simple_websocket.ws.ConnectionClosed:
+                raise websocket.WebSocketDisconnect()
 
     def send_bytes(self, data: bytes) -> None:
         with self.lock:
-            self.ws.send(data)
+            try:
+                self.ws.send(data)
+            except simple_websocket.ws.ConnectionClosed:
+                raise websocket.WebSocketDisconnect()
 
     async def receive(self):
         from anyio import to_thread
@@ -285,3 +291,7 @@ if has_solara_enterprise:
 
 if __name__ == "__main__":
     app.run(debug=False, port=8765)
+
+# we can only call this at the module level, which means that the solara script cannot import this
+# module. This is a difference with the asgi standard, which provides a lifecycle hook (see starlette.py)
+appmod.ensure_apps_initialized()

solara/server/jupyter/server_extension.py

@@ -14,6 +14,7 @@ def _load_jupyter_server_extension(server_app):
     import solara.server.app
 
     solara.server.app.apps["__default__"] = solara.server.app.AppScript("solara.server.jupyter.solara:Page")
+    solara.server.app.apps["__default__"].init()
 
     web_app = server_app.web_app
 

solara/server/kernel.py

@@ -54,7 +54,7 @@ def json_default(obj):
         import numpy as np
 
         if isinstance(obj, np.number):
-            return repr(obj.item())
+            return obj.item()
         else:
             raise TypeError("%r is not JSON serializable" % obj)
     else:
@@ -215,8 +215,20 @@ def send_websockets(websockets: Set[websocket.WebsocketWrapper], binary_msg):
     for ws in list(websockets):
         try:
             ws.send(binary_msg)
-        except:  # noqa
-            # in case of any issue, we simply remove it from the list
+        except websocket.WebSocketDisconnect:
+            # ignore the exception, we tried to send while websocket closed
+            # just remove it from the websocket set
+            try:
+                # websocket can be modified by another thread
+                websockets.remove(ws)
+            except KeyError:
+                pass  # already removed
+        except Exception as e:  # noqa
+            logger.exception("Error sending message: %s, closing websocket", e)
+            try:
+                ws.close()
+            except Exception as e:  # noqa
+                logger.exception("Error closing websocket: %s", e)
             try:
                 # websocket can be modified by another thread
                 websockets.remove(ws)
@@ -248,6 +260,8 @@ class SessionWebsocket(session.Session):
         header=None,
         metadata=None,
     ):
+        if stream is None:
+            return  # can happen when the kernel is closed but someone was still trying to send a message
         try:
             if isinstance(msg_or_type, dict):
                 msg = msg_or_type
@@ -314,6 +328,39 @@ class Kernel(ipykernel.kernelbase.Kernel):
         self.shell.display_pub.session = self.session
         self.shell.display_pub.pub_socket = self.iopub_socket
 
+    def close(self):
+        if self.comm_manager is None:
+            raise RuntimeError("Kernel already closed")
+        self.session.close()
+        self._cleanup_references()
+
+    def _cleanup_references(self):
+        try:
+            # all of these reduce the circular references
+            # making it easier for the garbage collector to clean up
+            self.shell_handlers.clear()
+            self.control_handlers.clear()
+            for comm_object in list(self.comm_manager.comms.values()):  # type: ignore
+                comm_object.close()
+            self.comm_manager.targets.clear()  # type: ignore
+            # self.comm_manager.kernel points to us, but we cannot set it to None
+            # so we remove the circular reference by setting the comm_manager to None
+            self.comm_manager = None  # type: ignore
+            self.session.parent = None  # type: ignore
+
+            self.shell.display_pub.session = None  # type: ignore
+            self.shell.display_pub.pub_socket = None  # type: ignore
+            del self.shell.__dict__
+            self.shell = None  # type: ignore
+            self.session.websockets.clear()
+            self.session.stream = None  # type: ignore
+            self.session = None  # type: ignore
+            self.stream.session = None  # type: ignore
+            self.stream = None  # type: ignore
+            self.iopub_socket = None  # type: ignore
+        except Exception:
+            logger.exception("Error cleaning up references from kernel, not fatal")
+
     async def _flush_control_queue(self):
         pass