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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solara-ui
-Version: 1.44.1
+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.1 → 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.1 → solara_ui-1.45.0}/solara/__init__.py

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

{solara_ui-1.44.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1-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.1 → 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.1 → 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

{solara_ui-1.44.1 → solara_ui-1.45.0}/solara/toestand.py

@@ -44,6 +44,7 @@ _DEBUG = False
 
 class ThreadLocal(threading.local):
     reactive_used: Optional[Set["ValueBase"]] = None
+    reactive_watch: Optional[Callable[["ValueBase"], None]] = None
 
 
 thread_local = ThreadLocal()
@@ -542,6 +543,8 @@ class Reactive(ValueBase[S]):
             warnings.warn("add_watch is deprecated, use .peek()", DeprecationWarning)
         if thread_local.reactive_used is not None:
             thread_local.reactive_used.add(self)
+        if thread_local.reactive_watch is not None:
+            thread_local.reactive_watch(self)
         # peek to avoid parents also adding themselves to the reactive_used set
         return self._storage.peek()
 
@@ -741,6 +744,8 @@ class ReactiveField(Reactive[T]):
             warnings.warn("add_watch is deprecated, use .peek()", DeprecationWarning)
         if thread_local.reactive_used is not None:
             thread_local.reactive_used.add(self)
+        if thread_local.reactive_watch is not None:
+            thread_local.reactive_watch(self)
         # peek to avoid parents also adding themselves to the reactive_used set
         return self._field.peek()
 
@@ -864,35 +869,43 @@ class AutoSubscribeContextManagerBase:
     # a render loop might trigger a new render loop of a differtent render context
     # so we want to save, and restore the current reactive_used
     reactive_used: Optional[Set[ValueBase]] = None
-    reactive_added_previous_run: Optional[Set[ValueBase]] = None
     subscribed: Dict[ValueBase, Callable]
+    subscribed_previous_run: Dict[ValueBase, Callable]
+    on_change: Callable[[], None]
+    previous_reactive_watch: Optional[Callable[["ValueBase"], None]] = None
 
     def __init__(self):
         self.subscribed = {}
-
-    def update_subscribers(self, change_handler):
-        assert self.reactive_used is not None
-        reactive_used = self.reactive_used
-        # remove subfields for which we already listen to it's root reactive value
-        reactive_used_subfields = {k for k in reactive_used if isinstance(k, ValueSubField)}
-        reactive_used = reactive_used - reactive_used_subfields
-        # only add subfield for which we don't listen to it's parent
-        for reactive_used_subfield in reactive_used_subfields:
-            if reactive_used_subfield._root not in reactive_used:
-                reactive_used.add(reactive_used_subfield)
-        added = reactive_used - (self.reactive_added_previous_run or set())
-
-        removed = (self.reactive_added_previous_run or set()) - reactive_used
-
-        for reactive in added:
-            if reactive not in self.subscribed:
-                unsubscribe = reactive.subscribe_change(change_handler)
-                self.subscribed[reactive] = unsubscribe
-        for reactive in removed:
-            unsubscribe = self.subscribed[reactive]
-            unsubscribe()
-            del self.subscribed[reactive]
-        self.reactive_added_previous_run = added
+        self.subscribed_previous_run = {}
+        self.on_change = lambda: None
+
+    def unsubscribe_previous(self):
+        removed = set(self.subscribed_previous_run or set()) - set(self.subscribed)
+        if removed:
+            for reactive in removed:
+                unsubscribe = self.subscribed_previous_run[reactive]
+                unsubscribe()
+                del self.subscribed_previous_run[reactive]
+
+    def add(self, reactive: ValueBase):
+        relevant_reactive = reactive
+        if isinstance(reactive, ValueSubField):
+            root = reactive._root
+            if root in self.subscribed or root in self.subscribed_previous_run:
+                # we already subscribed to this reactive's root
+                return
+            else:
+                # we are subscribing to this reactive's root
+                pass
+
+        # TODO: we could see if we are the root of any of the subscribed fields,
+        # and remove that field.
+        if relevant_reactive not in self.subscribed:
+            if relevant_reactive not in self.subscribed_previous_run:
+                unsubscribe = relevant_reactive.subscribe_change(lambda *args: self.on_change())
+                self.subscribed[relevant_reactive] = unsubscribe
+            else:
+                self.subscribed[relevant_reactive] = self.subscribed_previous_run[relevant_reactive]
 
     def unsubscribe_all(self):
         for reactive in self.subscribed:
@@ -900,12 +913,17 @@ class AutoSubscribeContextManagerBase:
             unsubscribe()
 
     def __enter__(self):
+        self.subscribed = {}
         self.reactive_used_before = thread_local.reactive_used
+        self.previous_reactive_watch = thread_local.reactive_watch
+        thread_local.reactive_watch = self.add
         self.reactive_used = thread_local.reactive_used = set()
-        assert thread_local.reactive_used is self.reactive_used, f"{hex(id(thread_local.reactive_used))} vs {hex(id(self.reactive_used))}"
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         thread_local.reactive_used = self.reactive_used_before
+        thread_local.reactive_watch = self.previous_reactive_watch
+        self.unsubscribe_previous()
+        self.subscribed_previous_run = self.subscribed.copy()
 
 
 class Context:
@@ -925,6 +943,7 @@ class Context:
             res1 = self.render_context.__exit__(exc_type, exc_val, exc_tb)
         else:
             res1 = None
+
         # pop the current context from the stack
         res2 = self.kernel_context.__exit__(exc_type, exc_val, exc_tb)
         return res1 or res2
@@ -949,20 +968,15 @@ class AutoSubscribeContextManagerReacton(AutoSubscribeContextManagerBase):
     def __enter__(self):
         _, set_counter = solara.use_state(0, key="auto_subscribe_force_update_counter")
 
-        def force_update(new_value, old_value):
+        def force_update():
             # can we do just x+1 to collapse multiple updates into one?
             set_counter(lambda x: x + 1)
 
         super().__enter__()
-
-        def update_subscribers():
-            self.update_subscribers(force_update)
-
-        solara.use_effect(update_subscribers, None)
+        self.on_change = force_update
 
         def on_close():
             def cleanup():
-                assert self.reactive_added_previous_run is not None
                 self.unsubscribe_all()
 
             return cleanup
@@ -971,20 +985,10 @@ class AutoSubscribeContextManagerReacton(AutoSubscribeContextManagerBase):
 
 
 class AutoSubscribeContextManager(AutoSubscribeContextManagerBase):
-    on_change: Callable[[], None]
-
     def __init__(self, on_change: Callable[[], None]):
         super().__init__()
         self.on_change = on_change
 
-    def __enter__(self):
-        super().__enter__()
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        value = super().__exit__(exc_type, exc_val, exc_tb)
-        self.update_subscribers(self.on_change)
-        return value
-
 
 # alias for compatibility
 State = Reactive