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

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

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

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

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

{solara_ui-1.45.0 → solara_ui-1.46.0}/solara/server/starlette.py

@@ -230,9 +230,9 @@ await to_thread.run_sync(my_update)
                 fut = self.portal.spawn_task(self.ws.receive)
 
             message = await asyncio.wrap_future(fut)
-        if "text" in message:
+        if message.get("text") is not None:
             return message["text"]
-        elif "bytes" in message:
+        elif message.get("bytes") is not None:
             return message["bytes"]
         elif message.get("type") == "websocket.disconnect":
             raise websocket.WebSocketDisconnect()

{solara_ui-1.45.0 → solara_ui-1.46.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.45.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.46.0-py2.py3-none-any.whl", keep_going=True)
     import solara
 
     el = solara.Warning("lala")

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

@@ -7,6 +7,7 @@ import inspect
 import logging
 import threading
 from enum import Enum
+import typing
 from typing import (
     Any,
     Callable,
@@ -19,6 +20,7 @@ from typing import (
     cast,
     overload,
 )
+import weakref
 
 import typing_extensions
 
@@ -35,6 +37,11 @@ else:
     from typing_extensions import Literal
 
 
+# Import kernel_context for typing only
+if typing.TYPE_CHECKING:
+    import solara.server.kernel_context
+
+
 R = TypeVar("R")
 T = TypeVar("T")
 P = typing_extensions.ParamSpec("P")
@@ -201,6 +208,7 @@ class TaskAsyncio(Task[P, R]):
     current_future: Optional[asyncio.Future] = None
     _cancel: Optional[Callable[[], None]] = None
     _retry: Optional[Callable[[], None]] = None
+    _context: Optional["weakref.ReferenceType[solara.server.kernel_context.VirtualKernelContext]"] = None
 
     def __init__(self, run_in_thread: bool, function: Callable[P, Coroutine[Any, Any, R]], key: str):
         self.run_in_thread = run_in_thread
@@ -249,6 +257,7 @@ class TaskAsyncio(Task[P, R]):
             import solara.server.kernel_context
 
             context = solara.server.kernel_context.get_current_context()
+            self._context = weakref.ref(context)
             call_event_loop = context.event_loop
         else:
             call_event_loop = _main_event_loop or asyncio.get_event_loop()
@@ -263,14 +272,32 @@ class TaskAsyncio(Task[P, R]):
                 try:
                     thread_event_loop.run_until_complete(current_task)
                 except asyncio.CancelledError as e:
-                    call_event_loop.call_soon_threadsafe(future.set_exception, e)
+                    try:
+                        call_event_loop.call_soon_threadsafe(future.set_exception, e)
+                    except Exception as e2:
+                        if not self._is_context_closed():
+                            logger.exception(
+                                "error setting exception from for task %s. Original exception: %s\nReason for failing to set exception: %s",
+                                self.function.__name__,
+                                e,
+                                e2,
+                            )
                 except Exception as e:
                     logger.exception("error running in thread")
-                    call_event_loop.call_soon_threadsafe(future.set_exception, e)
+                    try:
+                        call_event_loop.call_soon_threadsafe(future.set_exception, e)
+                    except Exception as e2:
+                        if not self._is_context_closed():
+                            logger.exception(
+                                "error setting exception from for task %s. Original exception: %s\nReason for failing to set exception: %s",
+                                self.function.__name__,
+                                e,
+                                e2,
+                            )
                     raise
 
             self._result.value = TaskResult[R](latest=self._last_value, _state=TaskState.STARTING)
-            thread = threading.Thread(target=runs_in_thread)
+            thread = threading.Thread(target=runs_in_thread, daemon=True)
             thread.start()
         else:
             self.current_task = current_task = asyncio.create_task(self._async_run(call_event_loop, future, args, kwargs))
@@ -281,6 +308,14 @@ class TaskAsyncio(Task[P, R]):
         assert running_task is not None
         return (self.current_task == _get_current_task()) and not running_task.cancelled()
 
+    def _is_context_closed(self):
+        if self._context is None:
+            return False
+        context = self._context()
+        if context is None:
+            return False
+        return context.closed_event.is_set()
+
     async def _async_run(self, call_event_loop: asyncio.AbstractEventLoop, future: asyncio.Future, args, kwargs) -> None:
         self._start_event.wait()
 
@@ -298,12 +333,34 @@ class TaskAsyncio(Task[P, R]):
                 if self.is_current() and not task_for_this_call.cancelled():  # type: ignore
                     self._result.value = TaskResult[R](value=value, latest=value, _state=TaskState.FINISHED, progress=self._last_progress)
                 logger.info("setting result to %r", value)
-                call_event_loop.call_soon_threadsafe(future.set_result, value)
+                try:
+                    call_event_loop.call_soon_threadsafe(future.set_result, value)
+                except Exception as e:
+                    if not self._is_context_closed():
+                        logger.exception(
+                            "error setting result from for task %s. Original exception: %s\nReason for failing to set result: %s", self.function.__name__, e, e
+                        )
+                    else:
+                        logger.debug(
+                            "ignoring error setting result from for task %s. Original exception: %s\nReason for failing to set result: %s",
+                            self.function.__name__,
+                            e,
+                            e,
+                        )
             except Exception as e:
                 if self.is_current():
                     logger.exception(e)
                     self._result.value = TaskResult[R](latest=self._last_value, exception=e, _state=TaskState.ERROR)
-                call_event_loop.call_soon_threadsafe(future.set_exception, e)
+                try:
+                    call_event_loop.call_soon_threadsafe(future.set_exception, e)
+                except Exception as e2:
+                    # we don't know if it is still useful to show this error, so we show it regardless if the context is closed or not
+                    logger.exception(
+                        "error setting exception from for task %s. Original exception: %s\nReason for failing to set exception: %s",
+                        self.function.__name__,
+                        e,
+                        e2,
+                    )
             # Although this seems like an easy way to handle cancellation, an early cancelled task will never execute
             # so this code will never execute, so we need to handle this in the cancel function in __call__
             # except asyncio.CancelledError as e:

{solara_ui-1.45.0 → solara_ui-1.46.0}/solara/website/pages/changelog/changelog.md

@@ -1,5 +1,15 @@
 # Solara Changelog
 
+## Version 1.45.0
+
+   * Bug Fix: Correctly handle expected websocket errors instead of logging them. [#1013](https://github.com/widgetti/solara/pull/1013)
+   * Bug Fix: Ensure component re-renders correctly when a reactive variable is updated from another thread during rendering. [#1030](https://github.com/widgetti/solara/pull/1030)
+   * Bug Fix: Allow calling async tasks from within threaded tasks. [#1029](https://github.com/widgetti/solara/pull/1029)
+   * Bug Fix: Replace deprecated `use_side_effect` calls with `use_effect`. [#1026](https://github.com/widgetti/solara/pull/1026)
+   * Bug Fix(pytest-ipywidgets): Support `pytest-playwright` version 0.7.0. [#1006](https://github.com/widgetti/solara/pull/1006)
+   * Docs: Ensure Twitter/OpenGraph meta tags are present on documentation pages. [#998](https://github.com/widgetti/solara/pull/998)
+   * Breaking change: Drop support for Python 3.6 due to CI runner deprecation. [#1032](https://github.com/widgetti/solara/pull/1032)
+
 ## Version 1.44.0
 
    * Feature: Separate `disable_send` and `disable_input` to allow typing but not sending or vice versa for the `ChatInput` component. [86fc2ad](https://github.com/widgetti/solara/commit/86fc2ad88a89ffe134eaa6700a8c416bcab036b4).

{solara_ui-1.45.0 → solara_ui-1.46.0}/tests/integration/ssg_test.py

@@ -1,4 +1,7 @@
 import threading
+import sys
+import pytest
+
 from pathlib import Path
 from typing import Optional
 
@@ -33,6 +36,7 @@ def SSG():
     return main
 
 
+@pytest.mark.skipif(sys.platform == "win32", reason="Skip on Windows, fails with playwright saying navigation was interrupted")
 def test_ssg(page_session: playwright.sync_api.Page, solara_server, solara_app, tmpdir):
     global text
     global context