solara-ui 1.46.0__tar.gz → 1.48.0__tar.gz

{solara_ui-1.46.0 → solara_ui-1.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solara-ui
-Version: 1.46.0
+Version: 1.48.0
 Dynamic: Summary
 Project-URL: Home, https://www.github.com/widgetti/solara
 Project-URL: Documentation, https://solara.dev

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/__init__.py

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

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/components/columns.py

@@ -145,7 +145,7 @@ def ColumnsResponsive(
 
     class_ = _combine_classes([*(["flex-nowrap"] if not wrap else []), *classes])
     style_flat = solara.util._flatten_style(style)
-    with rv.Row(class_=class_ if not wrap else "", style_=style_flat, no_gutters=not gutters, dense=gutters_dense) as main:
+    with rv.Row(class_=class_, style_=style_flat, no_gutters=not gutters, dense=gutters_dense) as main:
         for child, xsmall, small, medium, large, xlarge in zip(children, cycle(default), cycle(small), cycle(medium), cycle(large), cycle(xlarge)):
             with rv.Col(
                 cols=xsmall,

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/components/file_drop.vue

@@ -19,7 +19,7 @@
 <script>
 module.exports = {
   mounted() {
-    this.chunk_size = 2 * 1024 * 1024;
+    this.chunk_size = 1 * 1024 * 1024;
     this.$refs.dropzone.addEventListener('dragover', event => {
       event.preventDefault();
     });

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/server/app.py

@@ -8,6 +8,7 @@ import threading
 import traceback
 import warnings
 import weakref
+import html
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, cast
@@ -15,6 +16,7 @@ from typing import Any, Dict, List, Optional, cast
 import ipywidgets as widgets
 import reacton
 from reacton.core import Element, render
+from reacton import ipywidgets
 
 import solara
 import solara.lifecycle
@@ -26,7 +28,7 @@ from .utils import pdb_guard
 
 WebSocket = Any
 apps: Dict[str, "AppScript"] = {}
-thread_lock = threading.Lock()
+thread_lock = threading.RLock()
 
 logger = logging.getLogger("solara.server.app")
 
@@ -134,7 +136,7 @@ class AppScript:
             routes = solara.generate_routes_directory(self.path)
 
             if any(name for name in sys.modules.keys() if name.startswith(self.name)):
-                logger.warn(
+                logger.warning(
                     f"Directory {self.name} is also used as a package. This can cause modules to be loaded twice, and might "
                     "cause unexpected behavior. If you run solara from a different directory (e.g. the parent directory) you "
                     "can avoid this ambiguity."
@@ -232,12 +234,22 @@ class AppScript:
 
     def run(self):
         self.check()
-        if reload.reloader.requires_reload or self._first_execute_app is None:
+        if self._first_execute_app is None:
             with thread_lock:
-                if reload.reloader.requires_reload or self._first_execute_app is None:
-                    self._first_execute_app = None
-                    self._first_execute_app = self._execute()
-                    print("Re-executed app", self.name)  # noqa
+                if self._first_execute_app is None:
+                    try:
+                        self._first_execute_app = self._execute()
+                        print("Re-executed app", self.name)  # noqa
+                    except Exception as e:
+                        error = ""
+                        error = "".join(traceback.format_exception(None, e, e.__traceback__))
+                        print(error, file=sys.stdout, flush=True)  # noqa
+
+                        error = html.escape(error)
+                        self._first_execute_app = ipywidgets.HTML(value=f"<pre>{error}</pre>", layout=ipywidgets.Layout(overflow="auto"))
+                        # We now ran the app again, might contain new imports
+
+                        print("Failed to execute app, fix the error and save the file to reload")  # noqa
                     # We now ran the app again, might contain new imports
                     patch.patch_heavy_imports()
 
@@ -319,6 +331,9 @@ class AppScript:
                         except Exception as e:
                             logger.exception("Could not close render context: %s", e)
 
+            self._first_execute_app = None
+            self.run()
+
             # ask all contexts/users to reload
             for context in context_values:
                 with context:

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/server/static/solara_bootstrap.py

@@ -119,7 +119,7 @@ async def main():
     ]
     for dep in requirements:
         await micropip.install(dep, keep_going=True)
-    await micropip.install("/wheels/solara-1.46.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.48.0-py2.py3-none-any.whl", keep_going=True)
     import solara
 
     el = solara.Warning("lala")

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/tasks.py

@@ -6,6 +6,7 @@ import functools
 import inspect
 import logging
 import threading
+import warnings
 from enum import Enum
 import typing
 from typing import (
@@ -536,6 +537,7 @@ def task(
     f: None = None,
     *,
     prefer_threaded: bool = ...,
+    check_for_render_context: bool = ...,
 ) -> Callable[[Callable[P, R]], Task[P, R]]: ...
 
 
@@ -544,6 +546,7 @@ def task(
     f: Callable[P, Union[Coroutine[Any, Any, R], R]],
     *,
     prefer_threaded: bool = ...,
+    check_for_render_context: bool = ...,
 ) -> Task[P, R]: ...
 
 
@@ -551,6 +554,7 @@ def task(
     f: Union[None, Callable[P, Union[Coroutine[Any, Any, R], R]]] = None,
     *,
     prefer_threaded: bool = True,
+    check_for_render_context: bool = True,
 ) -> Union[Callable[[Callable[P, R]], Task[P, R]], Task[P, R]]:
     """Decorator to turn a function or coroutine function into a task.
 
@@ -764,20 +768,87 @@ def task(
         This ensures that even when a coroutine functions calls a blocking function the UI is still responsive.
         On platform where threads are not supported (like Pyodide / WASM / Emscripten / PyScript), a coroutine
         function will always run in the current event loop.
+    - `check_for_render_context` - bool: If true, we will check if we are in a render context, and if so, we will
+        warn you that you should probably be using `use_task` instead of `task`.
 
     ```
 
     """
 
+    def check_if_we_should_use_use_task():
+        import reacton.core
+
+        in_reacton_context = reacton.core.get_render_context(required=False) is not None
+        if not in_reacton_context:
+            # We are not in a reacton context, so we should not (and cannot) use use_task
+            return
+        from .toestand import _find_outside_solara_frame
+
+        frame = _find_outside_solara_frame()
+        if frame is None:
+            # We cannot determine which frame we are in, just skip this check
+            return
+        import inspect
+
+        tb = inspect.getframeinfo(frame)
+        msg = """You are calling task(...) from a component, while you should probably be using use_task.
+
+Reason:
+- task(...) creates a new task object on every render, and should only be used outside of a component.
+- use_task(...) returns the same task object on every render, and should be used inside a component.
+
+Example:
+@solara.component
+def Page():
+    @task  # This is wrong, this creates a new task object on every render
+    def my_task():
+        ...
+
+Instead, you should do:
+@solara.component
+def Page():
+    @use_task
+    def my_task():
+        ...
+
+"""
+        if tb:
+            if tb.code_context:
+                code = tb.code_context[0]
+            else:
+                code = "<No code context available>"
+            msg += f"This warning was triggered from:\n{tb.filename}:{tb.lineno}\n{code.strip()}"
+
+        # Check if the call is within a use_memo context by inspecting the call stack
+        if frame:
+            caller_frame = frame.f_back
+            # Check a few frames up the stack (e.g., up to 5) for 'use_memo'
+            for _ in range(5):
+                if caller_frame is None:
+                    break
+                func_name = caller_frame.f_code.co_name
+                module_name = caller_frame.f_globals.get("__name__", "")
+                if func_name == "use_memo" and (module_name.startswith("solara.") or module_name.startswith("reacton.")):
+                    # We are in a use_memo (or a context that should not trigger the warning)
+                    return
+                caller_frame = caller_frame.f_back
+
+        warnings.warn(msg)
+
     def wrapper(f: Union[None, Callable[P, Union[Coroutine[Any, Any, R], R]]]) -> Task[P, R]:
+        if check_for_render_context:
+            check_if_we_should_use_use_task()
         # we use wraps to make the key of the reactive variable more unique
         # and less likely to mixup during hot reloads
+        assert f is not None
+        key = solara.toestand._create_key_callable(f)
+
         @functools.wraps(f)  # type: ignore
         def create_task():
             if inspect.iscoroutinefunction(f):
-                return TaskAsyncio[P, R](prefer_threaded and has_threads, f, key=solara.toestand._create_key_callable(create_task))
+                return TaskAsyncio[P, R](prefer_threaded and has_threads, f, key=key)
             else:
-                return TaskThreaded[P, R](cast(Callable[P, R], f), key=solara.toestand._create_key_callable(create_task))
+                return TaskThreaded[P, R](cast(Callable[P, R], f), key=key)
 
         return cast(Task[P, R], Proxy(create_task))
 
@@ -797,46 +868,46 @@ def use_task(
     dependencies: Literal[None] = ...,
     raise_error=...,
     prefer_threaded=...,
-) -> Callable[[Callable[[], R]], "Task[[], R]"]: ...
+) -> Callable[[Callable[P, R]], "Task[P, R]"]: ...
 
 
 @overload
 def use_task(
-    f: Callable[[], R],
+    f: None = None,
     *,
-    dependencies: Literal[None] = ...,
+    dependencies: List = ...,
     raise_error=...,
     prefer_threaded=...,
-) -> "Task[[], R]": ...
+) -> Callable[[Callable[[], R]], "Task[[], R]"]: ...
 
 
 @overload
 def use_task(
-    f: None = None,
+    f: Callable[[], R],
     *,
     dependencies: List = ...,
     raise_error=...,
     prefer_threaded=...,
-) -> Callable[[Callable[[], R]], "Task[[], R]"]: ...
+) -> "Task[[], R]": ...
 
 
 @overload
 def use_task(
-    f: Callable[[], R],
+    f: Callable[P, R],
     *,
-    dependencies: List = ...,
+    dependencies: Literal[None] = ...,
     raise_error=...,
     prefer_threaded=...,
-) -> "Task[[], R]": ...
+) -> "Task[P, R]": ...
 
 
 def use_task(
-    f: Union[None, Callable[[], R]] = None,
+    f: Union[None, Callable[P, R]] = None,
     *,
     dependencies: Union[None, List] = [],
     raise_error=True,
     prefer_threaded=True,
-) -> Union[Callable[[Callable[[], R]], "Task[[], R]"], "Task[[], R]"]:
+) -> Union[Callable[[Callable[P, R]], "Task[P, R]"], "Task[P, R]"]:
     """A hook that runs a function or coroutine function as a task and returns the result.
 
     Allows you to run code in the background, with the UI available to the user. This is useful for long running tasks,
@@ -916,7 +987,7 @@ def use_task(
 
     def wrapper(f):
         def create_task() -> "Task[[], R]":
-            return task(f, prefer_threaded=prefer_threaded)
+            return task(f, prefer_threaded=prefer_threaded, check_for_render_context=False)
 
         task_instance = solara.use_memo(create_task, dependencies=[])
         # we always update the function so we do not have stale data in the function

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/test/pytest_plugin.py

@@ -334,7 +334,7 @@ class ServerVoila(ServerBase):
 
     def serve(self):
         if self.has_started():
-            raise RuntimeError("Jupyter server already running, use lsof -i :{self.port} to find the process and kill it")
+            raise RuntimeError(f"Jupyter server already running, use lsof -i :{self.port} to find the process and kill it")
         cmd = (
             "voila --no-browser --VoilaTest.log_level=DEBUG --Voila.port_retries=0 --VoilaExecutor.timeout=240"
             f' --Voila.port={self.port} --show_tracebacks=True "{self.notebook_path}" --enable_nbextensions=True'

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/toestand.py

@@ -343,6 +343,7 @@ def _is_internal_module(file_name: str):
     return (
         file_name_parts[-2:] == ["solara", "toestand.py"]
         or file_name_parts[-2:] == ["solara", "reactive.py"]
+        or file_name_parts[-2:] == ["solara", "tasks.py"]
         or file_name_parts[-2:] == ["solara", "_stores.py"]
         or file_name_parts[-3:] == ["solara", "hooks", "use_reactive.py"]
         or file_name_parts[-2:] == ["reacton", "core.py"]
@@ -442,7 +443,7 @@ reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
             raise ValueError(msg)
 
 
-def _create_key_callable(f: Callable[[], S]):
+def _create_key_callable(f: Callable):
     try:
         prefix = f.__qualname__
     except Exception:

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/widgets/vue/gridlayout.vue

@@ -3,14 +3,15 @@
     <div v-if="gridlayout_loaded" style="padding: 0px; width: 100%;">
        <grid-layout
             :layout.sync="grid_layout"
-            :col-num="12"
-            :row-height="30"
+            :col-num="col_num"
+            :row-height="row_height"
             :is-draggable="draggable"
             :is-resizable="resizable"
             :is-mirrored="false"
             :vertical-compact="true"
             :margin="[10, 10]"
             :use-css-transforms="true"
+            @layout-updated="onLayoutUpdated"
     >
 
         <grid-item v-for="item in grid_layout"
@@ -49,6 +50,9 @@ module.exports = {
           // this will cause bqplot to layout itself
           window.dispatchEvent(new Event('resize'));
         },
+        onLayoutUpdated(layout) {
+          this.layout_updated(layout);
+        },
         import(deps) {
           return this.loadRequire().then(
             () => {

{solara_ui-1.46.0 → solara_ui-1.48.0}/solara/widgets/widgets.py

@@ -52,6 +52,13 @@ class GridLayout(v.VuetifyTemplate):
     draggable = traitlets.CBool(True).tag(sync=True)
     resizable = traitlets.CBool(True).tag(sync=True)
     cdn = traitlets.Unicode(None, allow_none=True).tag(sync=True)
+    on_layout_updated = traitlets.traitlets.Callable(None, allow_none=True)
+    col_num = traitlets.Int(12).tag(sync=True)
+    row_height = traitlets.Int(30).tag(sync=True)
+
+    def vue_layout_updated(self, *args):
+        if self.on_layout_updated is not None:
+            self.on_layout_updated(*args)
 
     @traitlets.default("cdn")
     def _cdn(self):

{solara_ui-1.46.0 → solara_ui-1.48.0}/tests/unit/task_test.py

@@ -1,5 +1,6 @@
 import asyncio
 import time
+import warnings
 
 import ipyvuetify as v
 import pytest
@@ -652,3 +653,31 @@ def test_update_while_rendering():
 
     box, rc = solara.render(Test(), handle_error=False)
     rc.find(children=["value = 20"]).wait_for(timeout=3)
+
+
+def test_task_decorator_warning_in_component():
+    with pytest.warns(UserWarning, match=r"You are calling task.*"):
+
+        @solara.component
+        def ComponentWithTask():
+            @solara.tasks.task
+            def my_task_in_component():
+                return "done"
+
+            return solara.Text("ComponentWithTask")
+
+        solara.render(ComponentWithTask(), handle_error=False)
+
+    # Test that no warning is issued when task is used with use_memo
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")  # Treat all warnings as errors
+
+        @solara.component
+        def ComponentWithTaskInMemo():
+            def my_job_for_memo():
+                return "done"
+
+            solara.use_memo(lambda: solara.tasks.task(my_job_for_memo), dependencies=[])
+            return solara.Text("ComponentWithTaskInMemo")
+
+        solara.render_fixed(ComponentWithTaskInMemo(), handle_error=False)

{solara_ui-1.46.0 → solara_ui-1.48.0}/tests/unit/toestand_test.py

@@ -1303,6 +1303,8 @@ def test_computed_reload(no_kernel_context):
             module = route.module
             assert text.widget.v_model == "3.0"
             solara.server.reload.reloader.requires_reload = True
+            assert solara.server.reload.reloader.on_change is not None
+            solara.server.reload.reloader.on_change("notimportant.py")
             kernel_context.restart()
         solara.toestand.KernelStore._type_counter.clear()
         c = app.run()