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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solara-ui
-Version: 1.44.0
+Version: 1.45.0
 Dynamic: Summary
 Project-URL: Home, https://www.github.com/widgetti/solara
 Project-URL: Documentation, https://solara.dev
@@ -27,6 +27,7 @@ License: The MIT License (MIT)
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
         THE SOFTWARE.
 Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7
 Requires-Dist: humanize
 Requires-Dist: ipyvue>=1.9.0
 Requires-Dist: ipyvuetify>=1.6.10

{solara_ui-1.44.0 → solara_ui-1.45.0}/pyproject.toml

@@ -8,6 +8,7 @@ name = "solara-ui"
 readme = "README.md"
 authors = [{name = "Maarten A. Breddels", email = "maartenbreddels@gmail.com"}]
 license = {file = "LICENSE"}
+requires-python = ">=3.7"
 classifiers = ["License :: OSI Approved :: MIT License"]
 dynamic = ["version", "description"]
 packages = [
@@ -93,7 +94,9 @@ line-length = 160
 [tool.pytest.ini_options]
 addopts = "--ignore=tests/integration/app_widget.py  --ignore=tests/unit/solara_test_apps"
 timeout = 180
-
+filterwarnings = [
+    'ignore:.*pyzmq now works with default tornado and asyncio eventloops.*:DeprecationWarning',
+]
 
 [tool.codespell]
 skip='equis-in-vidi.md,substiterat-vati.md,.*,solara/website/build,*.svg,highlight-dark.css,packages/**/dist/*,node_modules,packages/solara-assets,package*.json,tsconfig.tsbuildinfo,*.csv'

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

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

{solara_ui-1.44.0 → solara_ui-1.45.0}/solara/components/dataframe.py

@@ -76,7 +76,7 @@ def Table(df, n=5):
             output_real.outputs = tuple()
             output_real.append_display_data(df)
 
-    solara.use_side_effect(output)
+    solara.use_effect(output)
     return output_c
 
 
@@ -204,7 +204,7 @@ def ScatterCard(df, x=None, y=None, color=None):
     dff = df
     if filter:
         dff = df[filter]
-    columns = df.get_column_names()
+    columns = use_df_column_names(df)
     max_points = 1000
     floats = [k for k in columns if df[k].dtype == float]
     #     flots = df.get_column_names()
@@ -353,7 +353,7 @@ def HeatmapCard(df, x=None, y=None, debounce=True):
     selection = filter
     # print("unfiltered", dff is df)
 
-    items = df.get_column_names()
+    items = use_df_column_names(df)
     floats = [k for k in items if df[k].dtype == float]
 
     with v.Card(elevation=2, height=cardheight) as main:

{solara_ui-1.44.0 → solara_ui-1.45.0}/solara/components/file_drop.py

@@ -58,7 +58,7 @@ def _FileDrop(
 
         set_wired_files(cast(typing.List[FileInfo], real.get_files()))
 
-    solara.use_side_effect(wire_files, [file_info])
+    solara.use_effect(wire_files, [file_info])
 
     def handle_file(cancel: threading.Event):
         if not wired_files:

{solara_ui-1.44.0 → solara_ui-1.45.0}/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,

{solara_ui-1.44.0 → solara_ui-1.45.0}/solara/server/kernel.py

@@ -227,8 +227,10 @@ def send_websockets(websockets: Set[websocket.WebsocketWrapper], binary_msg):
             logger.exception("Error sending message: %s, closing websocket", e)
             try:
                 ws.close()
-            except Exception as e:  # noqa
-                logger.exception("Error closing websocket: %s", e)
+            except websocket.WebSocketDisconnect:
+                pass  # was already closed, which triggered the original exception
+            except Exception as e2:  # noqa
+                logger.exception("Error closing websocket: %s %s", e, e2)
             try:
                 # websocket can be modified by another thread
                 websockets.remove(ws)

{solara_ui-1.44.0 → solara_ui-1.45.0}/solara/server/kernel_context.py

@@ -77,6 +77,7 @@ class VirtualKernelContext:
     closed_event: threading.Event = dataclasses.field(default_factory=threading.Event)
     _on_close_callbacks: List[Callable[[], None]] = dataclasses.field(default_factory=list)
     lock: threading.RLock = dataclasses.field(default_factory=threading.RLock)
+    event_loop: asyncio.AbstractEventLoop = dataclasses.field(default_factory=asyncio.get_event_loop)
 
     def __post_init__(self):
         with self:

{solara_ui-1.44.0 → solara_ui-1.45.0}/solara/server/patch.py

@@ -407,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_ui-1.44.0 → solara_ui-1.45.0}/solara/server/starlette.py

@@ -132,29 +132,46 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
         # and re-raise it as a websocket.WebSocketDisconnect
         try:
             await self.ws.send_bytes(data)
-        except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
+        except RuntimeError as e:
             # starlette throws a RuntimeError once you call send after the connection is closed
-            if isinstance(e, RuntimeError) and "close message" in repr(e):
+            # or RuntimeError: Unexpected ASGI message 'websocket.send', after sending 'websocket.close' or response already completed.
+            # from uvicorn.protocols.websockets.websockets_impl.py
+            if "close message" in repr(e) or "websocket.close" in repr(e):
                 raise websocket.WebSocketDisconnect() from e
             else:
                 raise
+        except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
+            raise websocket.WebSocketDisconnect() from e
 
     async def _send_text_exc(self, data: str):
         # make sures we catch the starlette/websockets specific exception
         # and re-raise it as a websocket.WebSocketDisconnect
         try:
             await self.ws.send_text(data)
-        except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
-            if isinstance(e, RuntimeError) and "close message" in repr(e):
+        except RuntimeError as e:
+            if "close message" in repr(e) or "websocket.close" in repr(e):
                 raise websocket.WebSocketDisconnect() from e
             else:
                 raise
+        except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
+            raise websocket.WebSocketDisconnect() from e
 
     def close(self):
+        async def _close_exc():
+            try:
+                await self.ws.close()
+            except RuntimeError as e:
+                if "close message" in repr(e) or "websocket.close" in repr(e):
+                    raise websocket.WebSocketDisconnect() from e
+                else:
+                    raise
+            except (websockets.exceptions.ConnectionClosed, starlette.websockets.WebSocketDisconnect, RuntimeError) as e:
+                raise websocket.WebSocketDisconnect() from e
+
         if self.portal is None:
-            asyncio.ensure_future(self.ws.close())
+            asyncio.ensure_future(_close_exc())
         else:
-            self.portal.call(self.ws.close)
+            self.portal.call(_close_exc)
 
     def send_text(self, data: str) -> None:
         if self.portal is None:

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

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

@@ -25,6 +25,7 @@ import typing_extensions
 import solara
 import solara.util
 from solara.toestand import Singleton
+from solara import _using_solara_server
 
 from .toestand import Ref as ref
 
@@ -41,6 +42,24 @@ P = typing_extensions.ParamSpec("P")
 logger = logging.getLogger("solara.task")
 
 has_threads = solara.util.has_threads
+_main_event_loop: Optional[asyncio.AbstractEventLoop] = None
+try:
+    # this will be the event loop in Jupyter/IPython
+    # on Python >=3.12, get_running_loop() is preferred
+    if sys.version_info >= (3, 12):
+        _main_event_loop = asyncio.get_running_loop()
+    else:
+        _main_event_loop = asyncio.get_event_loop()
+except RuntimeError:
+    pass
+
+
+def _get_current_task():
+    # asyncio.current_task() is not available in Python 3.6
+    if sys.version_info >= (3, 7):
+        return asyncio.current_task()
+    else:
+        return asyncio.Task.current_task()
 
 
 class TaskState(Enum):
@@ -201,7 +220,6 @@ class TaskAsyncio(Task[P, R]):
             raise RuntimeError("Cannot retry task, never started")
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> None:
-        self.current_future = future = asyncio.Future[R]()
         self._last_progress = None
         current_task: asyncio.Task[None]
         if self.current_task:
@@ -214,7 +232,7 @@ class TaskAsyncio(Task[P, R]):
             event_loop = current_task.get_loop()
             # cancel after cancel is a no-op
             self._cancel = lambda: None
-            if asyncio.current_task() == current_task:
+            if _get_current_task() == current_task:
                 if event_loop == asyncio.get_event_loop():
                     # we got called in our own task and event loop
                     raise _CancelledErrorInOurTask()
@@ -227,7 +245,15 @@ class TaskAsyncio(Task[P, R]):
 
         self._cancel = cancel
         self._retry = retry
-        call_event_loop = asyncio.get_event_loop()
+        if _using_solara_server():
+            import solara.server.kernel_context
+
+            context = solara.server.kernel_context.get_current_context()
+            call_event_loop = context.event_loop
+        else:
+            call_event_loop = _main_event_loop or asyncio.get_event_loop()
+
+        self.current_future = future = call_event_loop.create_future()
 
         if self.run_in_thread:
             thread_event_loop = asyncio.new_event_loop()
@@ -253,12 +279,12 @@ class TaskAsyncio(Task[P, R]):
     def is_current(self):
         running_task = self.current_task
         assert running_task is not None
-        return (self.current_task == asyncio.current_task()) and not running_task.cancelled()
+        return (self.current_task == _get_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()
+        task_for_this_call = _get_current_task()
         assert task_for_this_call is not None
 
         if self.is_current():

{solara_ui-1.44.0 → solara_ui-1.45.0}/solara/test/pytest_plugin.py

@@ -9,11 +9,12 @@ import sys
 import textwrap
 import threading
 import typing
+import tempfile
 import urllib.parse
 import uuid
 from io import BytesIO
 from pathlib import Path
-from typing import Any, Callable, Dict, Generator, List, Union
+from typing import Any, Callable, Dict, Generator, List, Union, cast
 
 import ipywidgets as widgets
 import pytest
@@ -55,74 +56,143 @@ def solara_server(pytestconfig: Any, request):
         webserver.stop_serving()
 
 
-@pytest.fixture(scope="session")
-def context_session(
-    browser: "playwright.sync_api.Browser",
-    browser_context_args: Dict,
-    pytestconfig: Any,
-    request: pytest.FixtureRequest,
-) -> Generator["playwright.sync_api.BrowserContext", None, None]:
-    from playwright.sync_api import Error, Page
-    from pytest_playwright.pytest_playwright import _build_artifact_test_folder
-    from slugify import slugify  # type: ignore
-
-    pages: List[Page] = []
-    context = browser.new_context(**browser_context_args)
-    context.on("page", lambda page: pages.append(page))
-
-    tracing_option = pytestconfig.getoption("--tracing")
-    capture_trace = tracing_option in ["on", "retain-on-failure"]
-    if capture_trace:
-        context.tracing.start(
-            title=slugify(request.node.nodeid),
-            screenshots=True,
-            snapshots=True,
-            sources=True,
-        )
-
-    # decrease timeout from 30s to 10s
-    context.set_default_timeout(TIMEOUT * 1000)
-    yield context
-
-    # If request.node is missing rep_call, then some error happened during execution
-    # that prevented teardown, but should still be counted as a failure
-    failed = request.node.rep_call.failed if hasattr(request.node, "rep_call") else True
-
-    if capture_trace:
-        retain_trace = tracing_option == "on" or (failed and tracing_option == "retain-on-failure")
-        if retain_trace:
-            trace_path = _build_artifact_test_folder(pytestconfig, request, "trace.zip")
-            context.tracing.stop(path=trace_path)
-        else:
-            context.tracing.stop()
-
-    screenshot_option = pytestconfig.getoption("--screenshot")
-    capture_screenshot = screenshot_option == "on" or (failed and screenshot_option == "only-on-failure")
-    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")
-            try:
-                page.screenshot(timeout=5000, path=screenshot_path)
-            except Error:
-                pass
-
-    context.close()
-
-    video_option = pytestconfig.getoption("--video")
-    preserve_video = video_option == "on" or (failed and video_option == "retain-on-failure")
-    if preserve_video:
-        for page in pages:
-            video = page.video
-            if not video:
-                continue
-            try:
-                video_path = video.path()
-                file_name = os.path.basename(video_path)
-                video.save_as(path=_build_artifact_test_folder(pytestconfig, request, file_name))
-            except Error:
-                # Silent catch empty videos.
-                pass
+try:
+    from pytest_playwright.pytest_playwright import connect_options  # noqa
+
+    has_pytest_070 = True
+except ImportError:
+    has_pytest_070 = False
+
+
+if has_pytest_070:
+    # pytest-playwright >= 0.7.0
+    from pytest_playwright.pytest_playwright import Browser, CreateContextCallback, BrowserContext, Playwright, ArtifactsRecorder, _truncate_file_name
+    from slugify import slugify
+
+    @pytest.fixture(scope="session")
+    def output_path_session(pytestconfig: Any, request: pytest.FixtureRequest) -> str:
+        output_dir = Path(pytestconfig.getoption("--output")).absolute()
+        return os.path.join(output_dir, _truncate_file_name(slugify(request.node.nodeid)))
+
+    @pytest.fixture(scope="session")
+    def _artifacts_recorder_session(
+        request: pytest.FixtureRequest,
+        output_path_session: str,
+        playwright: Playwright,
+        pytestconfig: Any,
+        _pw_artifacts_folder: tempfile.TemporaryDirectory,
+    ) -> Generator["ArtifactsRecorder", None, None]:
+        artifacts_recorder = ArtifactsRecorder(pytestconfig, request, output_path_session, playwright, _pw_artifacts_folder)
+        yield artifacts_recorder
+        # If request.node is missing rep_call, then some error happened during execution
+        # that prevented teardown, but should still be counted as a failure
+        failed = request.node.rep_call.failed if hasattr(request.node, "rep_call") else True
+        artifacts_recorder.did_finish_test(failed)
+
+    @pytest.fixture(scope="session")
+    def new_context_session(
+        browser: Browser,
+        browser_context_args: Dict,
+        _artifacts_recorder_session: "ArtifactsRecorder",
+        request: pytest.FixtureRequest,
+    ) -> Generator[CreateContextCallback, None, None]:
+        browser_context_args = browser_context_args.copy()
+        context_args_marker = next(request.node.iter_markers("browser_context_args"), None)
+        additional_context_args = context_args_marker.kwargs if context_args_marker else {}
+        browser_context_args.update(additional_context_args)
+        contexts: List[BrowserContext] = []
+
+        def _new_context(**kwargs: Any) -> BrowserContext:
+            context = browser.new_context(**browser_context_args, **kwargs)
+            original_close = context.close
+
+            def _close_wrapper(*args: Any, **kwargs: Any) -> None:
+                contexts.remove(context)
+                _artifacts_recorder_session.on_will_close_browser_context(context)
+                original_close(*args, **kwargs)
+
+            context.close = _close_wrapper
+            contexts.append(context)
+            _artifacts_recorder_session.on_did_create_browser_context(context)
+            return context
+
+        yield cast(CreateContextCallback, _new_context)
+        for context in contexts.copy():
+            context.close()
+
+    @pytest.fixture(scope="session")
+    def context_session(new_context_session):
+        return new_context_session()
+else:
+
+    @pytest.fixture(scope="session")
+    def context_session(
+        browser: "playwright.sync_api.Browser",
+        browser_context_args: Dict,
+        pytestconfig: Any,
+        request: pytest.FixtureRequest,
+    ) -> Generator["playwright.sync_api.BrowserContext", None, None]:
+        from playwright.sync_api import Error, Page
+        from pytest_playwright.pytest_playwright import _build_artifact_test_folder
+        from slugify import slugify  # type: ignore
+
+        pages: List[Page] = []
+        context = browser.new_context(**browser_context_args)
+        context.on("page", lambda page: pages.append(page))
+
+        tracing_option = pytestconfig.getoption("--tracing")
+        capture_trace = tracing_option in ["on", "retain-on-failure"]
+        if capture_trace:
+            context.tracing.start(
+                title=slugify(request.node.nodeid),
+                screenshots=True,
+                snapshots=True,
+                sources=True,
+            )
+
+        # decrease timeout from 30s to 10s
+        context.set_default_timeout(TIMEOUT * 1000)
+        yield context
+
+        # If request.node is missing rep_call, then some error happened during execution
+        # that prevented teardown, but should still be counted as a failure
+        failed = request.node.rep_call.failed if hasattr(request.node, "rep_call") else True
+
+        if capture_trace:
+            retain_trace = tracing_option == "on" or (failed and tracing_option == "retain-on-failure")
+            if retain_trace:
+                trace_path = _build_artifact_test_folder(pytestconfig, request, "trace.zip")
+                context.tracing.stop(path=trace_path)
+            else:
+                context.tracing.stop()
+
+        screenshot_option = pytestconfig.getoption("--screenshot")
+        capture_screenshot = screenshot_option == "on" or (failed and screenshot_option == "only-on-failure")
+        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")
+                try:
+                    page.screenshot(timeout=5000, path=screenshot_path)
+                except Error:
+                    pass
+
+        context.close()
+
+        video_option = pytestconfig.getoption("--video")
+        preserve_video = video_option == "on" or (failed and video_option == "retain-on-failure")
+        if preserve_video:
+            for page in pages:
+                video = page.video
+                if not video:
+                    continue
+                try:
+                    video_path = video.path()
+                    file_name = os.path.basename(video_path)
+                    video.save_as(path=_build_artifact_test_folder(pytestconfig, request, file_name))
+                except Error:
+                    # Silent catch empty videos.
+                    pass
 
 
 # page fixture that keeps open all the time, is faster