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

solara/__init__.py

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

solara/__main__.py

@@ -156,7 +156,7 @@ if "SOLARA_MODE" in os.environ:
     "--restart-dir",
     "restart_dirs",
     multiple=True,
-    help="Set restart directories explicitly, instead of using the current working" " directory.",
+    help="Set restart directories explicitly, instead of using the current working directory.",
     type=click.Path(exists=True),
 )
 @click.option(
@@ -172,7 +172,7 @@ if "SOLARA_MODE" in os.environ:
     "--workers",
     default=None,
     type=int,
-    help="Number of worker processes. Defaults to the $WEB_CONCURRENCY environment" " variable if available, or 1. Not valid with --auto-restart/-a.",
+    help="Number of worker processes. Defaults to the $WEB_CONCURRENCY environment variable if available, or 1. Not valid with --auto-restart/-a.",
 )
 @click.option(
     "--env-file",

solara/_stores.py

@@ -1,10 +1,16 @@
 import copy
 import dataclasses
 import inspect
-from typing import Callable, ContextManager, Generic, Optional, Union, cast
+import sys
+import threading
+from typing import Callable, ContextManager, Generic, Optional, Union, cast, Any
 import warnings
-from .toestand import ValueBase, KernelStore, S, _find_outside_solara_frame
+
+
+from .toestand import ValueBase, S, _find_outside_solara_frame, _DEBUG
+
 import solara.util
+import solara.settings
 
 
 class _PublicValueNotSet:
@@ -25,7 +31,7 @@ class StoreValue(Generic[S]):
 
 
 class MutateDetectorStore(ValueBase[S]):
-    def __init__(self, store: KernelStore[StoreValue[S]], equals=solara.util.equals_extra):
+    def __init__(self, store: ValueBase[StoreValue[S]], equals=solara.util.equals_extra):
         self._storage = store
         self._enabled = True
         super().__init__(equals=equals)
@@ -81,7 +87,7 @@ class MutateDetectorStore(ValueBase[S]):
                     code = tb.code_context[0]
                 else:
                     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}"
+                msg += f"The last value was read in the following code:\n{tb.filename}:{tb.lineno}\n{code}"
             raise ValueError(msg)
         elif not isinstance(store_value.set_value, _SetValueNotSet) and not self.equals(store_value.set_value, store_value.private):
             tb = store_value.set_traceback
@@ -114,7 +120,7 @@ Good (if you want to keep mutating your own list):
                     code = tb.code_context[0]
                 else:
                     code = "<No code context available>"
-                msg += "The last time the value was set was at:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+                msg += f"The last time the value was set was at:\n{tb.filename}:{tb.lineno}\n{code}"
             raise ValueError(msg)
 
     def _ensure_public_exists(self):
@@ -158,7 +164,7 @@ reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
                     code = tb.code_context[0]
                 else:
                     code = "<No code context available>"
-                warn += "This warning was triggered from:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+                warn += f"This warning was triggered from:\n{tb.filename}:{tb.lineno}\n{code}"
             warnings.warn(warn)
             self._enabled = False
 
@@ -187,3 +193,105 @@ reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
                 listener(new_value, previous_value)
 
         return self._storage.subscribe_change(listener_wrapper, scope=scope)
+
+
+class SharedStore(ValueBase[S]):
+    """Stores a single value, not kernel scoped."""
+
+    _traceback: Optional[inspect.Traceback]
+    _original_ref: Optional[S]
+    _original_ref_copy: Optional[S]
+
+    def __init__(self, value: S, equals: Callable[[Any, Any], bool] = solara.util.equals_extra, unwrap=lambda x: x):
+        # since a set can trigger events, which can trigger new updates, we need a recursive lock
+        self._lock = threading.RLock()
+        self.local = threading.local()
+        self.equals = equals
+
+        self._value = value
+        self._original_ref = None
+        self._original_ref_copy = None
+        self._unwrap = unwrap
+        self._mutation_detection = solara.settings.storage.mutation_detection
+        if self._mutation_detection:
+            frame = _find_outside_solara_frame()
+            if frame is not None:
+                self._traceback = inspect.getframeinfo(frame)
+            else:
+                self._traceback = None
+            self._original_ref = value
+            self._original_ref_copy = copy.deepcopy(self._original_ref)
+            if not self.equals(self._unwrap(self._original_ref), self._unwrap(self._original_ref_copy)):
+                msg = """The equals function for this reactive value returned False when comparing a deepcopy to itself.
+
+This reactive variable will not be able to detect mutations correctly, and is therefore disabled.
+
+To avoid this warning, and to ensure that mutation detection works correctly, please provide a better equals function to the reactive variable.
+A good choice for dataframes and numpy arrays might be solara.util.equals_pickle, which will also attempt to compare the pickled values of the objects.
+
+Example:
+df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
+"""
+                tb = self._traceback
+                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}"
+                warnings.warn(msg)
+                self._mutation_detection = False
+        super().__init__(equals=equals)
+
+    def _check_mutation(self):
+        if not self._mutation_detection:
+            return
+        current = self._unwrap(self._original_ref)
+        initial = self._unwrap(self._original_ref_copy)
+        if not self.equals(initial, current):
+            tb = self._traceback
+            if tb:
+                if tb.code_context:
+                    code = tb.code_context[0].strip()
+                else:
+                    code = "No code context available"
+                msg = f"Reactive variable was initialized at {tb.filename}:{tb.lineno} with {initial!r}, but was mutated to {current!r}.\n{code}"
+            else:
+                msg = f"Reactive variable was initialized with a value of {initial!r}, but was mutated to {current!r} (unable to report the location in the source code)."
+            raise ValueError(msg)
+
+    @property
+    def lock(self):
+        return self._lock
+
+    def peek(self):
+        self._check_mutation()
+        return self._value
+
+    def get(self):
+        self._check_mutation()
+        return self._value
+
+    def clear(self):
+        pass
+
+    def _get_scope_key(self):
+        return "GLOBAL"
+
+    def set(self, value: S):
+        self._check_mutation()
+        old = self.get()
+        if self.equals(old, value):
+            return
+        self._value = value
+
+        if _DEBUG:
+            import traceback
+
+            traceback.print_stack(limit=17, file=sys.stdout)
+
+            print("change old", old)  # noqa
+            print("change new", value)  # noqa
+
+        self.fire(value, old)

solara/cache.py

@@ -1,3 +1,4 @@
+from collections.abc import Hashable
 import hashlib
 import inspect
 import logging
@@ -50,6 +51,7 @@ if has_cachetools:
     class Memory(cachetools.LRUCache):
         def __init__(self, max_items=solara.settings.cache.memory_max_items):
             super().__init__(maxsize=max_items)
+
 else:
 
     class Memory(dict):  # type: ignore
@@ -64,7 +66,7 @@ def _default_key(*args, **kwargs):
 
 
 class MemoizedFunction(Generic[P, R]):
-    def __init__(self, function: Callable[P, R], key: Callable[P, R], storage: Optional[Storage], allow_nonlocals=False):
+    def __init__(self, function: Callable[P, R], key: Callable[P, Hashable], storage: Optional[Storage], allow_nonlocals=False):
         self.function = function
         f: Callable = self.function
         if not allow_nonlocals:
@@ -170,7 +172,7 @@ def memoize(
 @overload
 def memoize(
     function: None = None,
-    key: Callable[P, R] = ...,
+    key: Callable[P, Hashable] = ...,
     storage: Optional[Storage] = None,
     allow_nonlocals=False,
 ) -> Callable[[Callable[P, R]], MemoizedFunction[P, R]]: ...
@@ -187,7 +189,7 @@ def memoize(
 
 def memoize(
     function: Union[None, Callable[P, R]] = None,
-    key: Union[None, Callable[P, R]] = None,
+    key: Union[None, Callable[P, Hashable]] = None,
     storage: Optional[Storage] = None,
     allow_nonlocals: bool = False,
 ) -> Union[Callable[[Callable[P, R]], MemoizedFunction[P, R]], MemoizedFunction[P, R]]:
@@ -249,7 +251,7 @@ def memoize(
     def wrapper(func: Callable[P, R]) -> MemoizedFunction[P, R]:
         return MemoizedFunction[P, R](
             func,
-            cast(Callable[P, R], key or _default_key),
+            cast(Callable[P, Hashable], key or _default_key),
             storage,
             allow_nonlocals,
         )

solara/checks.py

@@ -164,7 +164,7 @@ def get_server_python_executable(silent: bool = False):
         else:
             python = pythons[0]
             if not silent:
-                warnings.warn("Found multiple find servers:\n%s\n" "We are assuming the server is running under Python executable: %s" % (info, python))
+                warnings.warn(f"Found multiple find servers:\n{info}\nWe are assuming the server is running under Python executable: {python}")
     else:
         python = pythons[0]
     return python

solara/components/select.py

@@ -174,7 +174,7 @@ def SelectMultiple(
             items=all_values,
             label=label,
             multiple=True,
-            dense=False,
+            dense=dense,
             disabled=disabled,
             class_=class_,
             style_=style_flat,

solara/components/style.py

@@ -101,5 +101,5 @@ module.exports = {
 {css_content}
 </style>
     """
-    # using .key avoids re-using the template, which causes a flicker (due to ipyvue)
+    # using .key avoids reusing the template, which causes a flicker (due to ipyvue)
     return v.VuetifyTemplate.element(template=template).key(key)

solara/hooks/use_reactive.py

@@ -1,6 +1,7 @@
 from typing import Any, Callable, Optional, TypeVar, Union
 
 import solara
+import solara.settings
 
 T = TypeVar("T")
 
@@ -105,7 +106,21 @@ def use_reactive(
 
     def create():
         if not isinstance(value, solara.Reactive):
-            return solara.reactive(value)
+            from solara._stores import SharedStore, MutateDetectorStore, StoreValue, _PublicValueNotSet, _SetValueNotSet
+            from solara.toestand import ValueBase
+
+            store: ValueBase[T]
+
+            if solara.settings.storage.mutation_detection is True:
+                shared_store = SharedStore[StoreValue[T]](
+                    StoreValue[T](private=value, public=_PublicValueNotSet(), get_traceback=None, set_value=_SetValueNotSet(), set_traceback=None),
+                    unwrap=lambda x: x.private,
+                )
+                store = MutateDetectorStore[T](shared_store, equals=equals)
+            else:
+                store = SharedStore(value, equals=equals)
+
+            return solara.Reactive(store)
 
     reactive_value = solara.use_memo(create, dependencies=[])
     if isinstance(value, solara.Reactive):

solara/lab/components/chat.py

@@ -32,7 +32,7 @@ def ChatBox(
     if "overflow-y" not in style_flat:
         style_flat += " overflow-y: auto;"
 
-    classes += ["chat-box"]
+    classes = [*classes, "chat-box"]
     with solara.Column(
         style=style_flat,
         classes=classes,
@@ -45,7 +45,10 @@ def ChatBox(
 def ChatInput(
     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] = [],
@@ -56,9 +59,11 @@ def ChatInput(
     # Arguments
 
     * `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.
+    * `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,14 +89,15 @@ 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"])
 
@@ -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/server/app.py

@@ -90,6 +90,7 @@ class AppScript:
             self.path = Path(spec.origin)
             self.directory = self.path.parent
         self._initialized = False
+        self._lock = threading.Lock()
 
     def init(self):
         try:
@@ -225,7 +226,9 @@ class AppScript:
 
     def check(self):
         if not self._initialized:
-            raise RuntimeError("Call solara.server.app.ensure_apps_initialized() first")
+            with self._lock:
+                if not self._initialized:
+                    self.init()
 
     def run(self):
         self.check()

solara/server/kernel_context.py

@@ -26,7 +26,7 @@ from ipywidgets import DOMWidget, Widget
 import solara.server.settings
 import solara.util
 
-from . import kernel, kernel_context, websocket
+from . import kernel, websocket
 from .. import lifecycle
 from .kernel import Kernel, WebsocketStreamWrapper
 
@@ -35,7 +35,7 @@ logger = logging.getLogger("solara.server.app")
 
 
 class Local(threading.local):
-    kernel_context_stack: Optional[List[Optional["kernel_context.VirtualKernelContext"]]] = None
+    kernel_context_stack: Optional[List[Optional["VirtualKernelContext"]]] = None
 
 
 local = Local()

solara/server/patch.py

@@ -174,6 +174,8 @@ def display_solara(
 # if display_id:
 #     return DisplayHandle(display_id)
 
+get_ipython_original = IPython.get_ipython
+
 
 def get_ipython():
     if kernel_context.has_current_context():
@@ -181,7 +183,7 @@ def get_ipython():
         our_fake_ipython = FakeIPython(context)
         return our_fake_ipython
     else:
-        return None
+        return get_ipython_original()
 
 
 class context_dict(MutableMapping):
@@ -405,6 +407,13 @@ def patch_matplotlib():
             # same as _get
             return self[key]
 
+        def clear(self):
+            # in matplotlib .clear is effectively a no-op
+            # see https://github.com/matplotlib/matplotlib/issues/25855
+            pass
+            # in the future, we may want to clear the context dict if this is fixed
+            # self._get_context_dict().clear()
+
         def _get_context_dict(self) -> dict:
             if not self._was_initialized:
                 # since we monkey patch the class after __init__ was called

solara/server/server.py

@@ -187,7 +187,7 @@ async def app_loop(
                     created_widgets_count = len(widgets_ids_after - widgets_ids)
                     close_widgets_count = len(widgets_ids - widgets_ids_after)
                     print(  # noqa: T201
-                        f"timing: total={t2-t0:.3f}s, deserialize={t1-t0:.3f}s, kernel={t2-t1:.3f}s"
+                        f"timing: total={t2 - t0:.3f}s, deserialize={t1 - t0:.3f}s, kernel={t2 - t1:.3f}s"
                         f" widget: created: {created_widgets_count} closed: {close_widgets_count}"
                     )
     finally:

solara/server/starlette.py

@@ -113,6 +113,7 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
         # we store a strong reference
         self.tasks: Set[asyncio.Task] = set()
         self.event_loop = asyncio.get_event_loop()
+        self._thread_id = threading.get_ident()
         if settings.main.experimental_performance:
             self.task = asyncio.ensure_future(self.process_messages_task())
 
@@ -133,7 +134,10 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
             await self.ws.send_bytes(data)
         except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
             # starlette throws a RuntimeError once you call send after the connection is closed
-            raise websocket.WebSocketDisconnect() from e
+            if isinstance(e, RuntimeError) and "close message" in repr(e):
+                raise websocket.WebSocketDisconnect() from e
+            else:
+                raise
 
     async def _send_text_exc(self, data: str):
         # make sures we catch the starlette/websockets specific exception
@@ -141,8 +145,10 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
         try:
             await self.ws.send_text(data)
         except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
-            # starlette throws a RuntimeError once you call send after the connection is closed
-            raise websocket.WebSocketDisconnect() from e
+            if isinstance(e, RuntimeError) and "close message" in repr(e):
+                raise websocket.WebSocketDisconnect() from e
+            else:
+                raise
 
     def close(self):
         if self.portal is None:
@@ -159,7 +165,19 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
             if settings.main.experimental_performance:
                 self.to_send.append(data)
             else:
-                self.portal.call(self._send_text_exc, data)
+                if self._thread_id == threading.get_ident():
+                    warnings.warn("""You are triggering a websocket send from the event loop thread.
+Support for this is experimental, and to avoid this message, make sure you trigger updates
+that trigger this from a different thread, e.g.:
+
+from anyio import to_thread
+await to_thread.run_sync(my_update)
+""")
+                    task = self.event_loop.create_task(self._send_text_exc(data))
+                    self.tasks.add(task)
+                    task.add_done_callback(self.tasks.discard)
+                else:
+                    self.portal.call(self._send_text_exc, data)
 
     def send_bytes(self, data: bytes) -> None:
         if self.portal is None:
@@ -170,6 +188,18 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
             if settings.main.experimental_performance:
                 self.to_send.append(data)
             else:
+                if self._thread_id == threading.get_ident():
+                    warnings.warn("""You are triggering a websocket send from the event loop thread.
+Support for this is experimental, and to avoid this message, make sure you trigger updates
+that trigger this from a different thread, e.g.:
+
+from anyio import to_thread
+await to_thread.run_sync(my_update)
+""")
+                    task = self.event_loop.create_task(self._send_bytes_exc(data))
+                    self.tasks.add(task)
+                    task.add_done_callback(self.tasks.discard)
+
                 self.portal.call(self._send_bytes_exc, data)
 
     async def receive(self):
@@ -350,7 +380,7 @@ async def root(request: Request, fullpath: str = ""):
     forwarded_proto = request.headers.get("x-forwarded-proto")
     host = request.headers.get("host")
     if forwarded_proto and forwarded_proto != request.scope["scheme"]:
-        warnings.warn(f"""Header x-forwarded-proto={forwarded_proto!r} does not match scheme={request.scope['scheme']!r} as given by the asgi framework (probably uvicorn)
+        warnings.warn(f"""Header x-forwarded-proto={forwarded_proto!r} does not match scheme={request.scope["scheme"]!r} as given by the asgi framework (probably uvicorn)
 
 This might be a configuration mismatch behind a reverse proxy and can cause issues with redirect urls, and auth.
 
@@ -409,10 +439,10 @@ This could be a configuration mismatch behind a reverse proxy and can cause issu
 See also https://solara.dev/documentation/getting_started/deploying/self-hosted
 """
         if "script-name" in request.headers:
-            msg += f"""It looks like the reverse proxy sets the script-name header to {request.headers['script-name']!r}
+            msg += f"""It looks like the reverse proxy sets the script-name header to {request.headers["script-name"]!r}
 """
         if "x-script-name" in request.headers:
-            msg += f"""It looks like the reverse proxy sets the x-script-name header to {request.headers['x-script-name']!r}
+            msg += f"""It looks like the reverse proxy sets the x-script-name header to {request.headers["x-script-name"]!r}
 """
         if configured_root_path:
             msg += f"""It looks like the root path was configured to {configured_root_path!r} in the settings
@@ -472,8 +502,8 @@ See also https://solara.dev/documentation/getting_started/deploying/self-hosted
         samesite = "none"
         secure = True
     elif request.base_url.hostname != "localhost":
-        warnings.warn(f"""Cookies with samesite=none require https, but according to the asgi framework, the scheme is {request.scope['scheme']!r}
-and the x-forwarded-proto header is {request.headers.get('x-forwarded-proto', 'http')!r}. We will fallback to samesite=lax.
+        warnings.warn(f"""Cookies with samesite=none require https, but according to the asgi framework, the scheme is {request.scope["scheme"]!r}
+and the x-forwarded-proto header is {request.headers.get("x-forwarded-proto", "http")!r}. We will fallback to samesite=lax.
 
 If you embed solara in an iframe, make sure you forward the x-forwarded-proto header correctly so that the session cookie can be set.
 

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.43.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.44.1-py2.py3-none-any.whl", keep_going=True)
     import solara
 
     el = solara.Warning("lala")

solara/tasks.py

@@ -104,6 +104,9 @@ class Task(Generic[P, R], abc.ABC):
         self._progress = ref(self._result.fields.progress)
         self._exception = ref(self._result.fields.exception)
         self._state_ = ref(self._result.fields._state)
+        # used for tests only
+        self._start_event = threading.Event()
+        self._start_event.set()
 
     @property
     def result(self) -> TaskResult[R]:
@@ -253,6 +256,8 @@ class TaskAsyncio(Task[P, R]):
         return (self.current_task == asyncio.current_task()) and not running_task.cancelled()
 
     async def _async_run(self, call_event_loop: asyncio.AbstractEventLoop, future: asyncio.Future, args, kwargs) -> None:
+        self._start_event.wait()
+
         task_for_this_call = asyncio.current_task()
         assert task_for_this_call is not None
 
@@ -304,6 +309,7 @@ class TaskThreaded(Task[P, R]):
         self.__qualname__ = function.__qualname__
         self.function = function
         self.lock = threading.Lock()
+        self._local = threading.local()
 
     def cancel(self) -> None:
         if self._cancel:
@@ -343,12 +349,17 @@ class TaskThreaded(Task[P, R]):
         current_thread.start()
 
     def is_current(self):
+        cancel_event = getattr(self._local, "cancel_event", None)
+        if cancel_event is not None and cancel_event.is_set():
+            return False
         return self._current_thread == threading.current_thread()
 
     def _run(self, _last_finished_event, previous_thread: Optional[threading.Thread], cancel_event, args, kwargs) -> None:
         # use_thread has this as default, which can make code run 10x slower
+        self._start_event.wait()
         intrusive_cancel = False
         wait_on_previous = False
+        self._local.cancel_event = cancel_event
 
         def runner():
             if wait_on_previous:
@@ -405,7 +416,7 @@ class TaskThreaded(Task[P, R]):
                     # this means this thread is cancelled not be request, but because
                     # a new thread is running, we can ignore this
             finally:
-                if self.is_current():
+                if self._current_thread == threading.current_thread():
                     self.running_thread = None
                     logger.info("thread done!")
                     if cancel_event.is_set():

solara/test/pytest_plugin.py

@@ -101,7 +101,7 @@ def context_session(
     if capture_screenshot:
         for index, page in enumerate(pages):
             human_readable_status = "failed" if failed else "finished"
-            screenshot_path = _build_artifact_test_folder(pytestconfig, request, f"test-{human_readable_status}-{index+1}.png")
+            screenshot_path = _build_artifact_test_folder(pytestconfig, request, f"test-{human_readable_status}-{index + 1}.png")
             try:
                 page.screenshot(timeout=5000, path=screenshot_path)
             except Error:
@@ -144,13 +144,14 @@ def solara_app(solara_server):
     used_app = None
 
     @contextlib.contextmanager
-    def run(app: Union[solara.server.app.AppScript, str]):
+    def run(app: Union[solara.server.app.AppScript, str], init=True):
         nonlocal used_app
         if "__default__" in solara.server.app.apps:
             solara.server.app.apps["__default__"].close()
         if isinstance(app, str):
             app = solara.server.app.AppScript(app)
-            app.init()
+            if init:
+                app.init()
         used_app = app
         solara.server.app.apps["__default__"] = app
         try: