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

solara/server/app.py

@@ -7,6 +7,7 @@ import sys
 import threading
 import traceback
 import warnings
+import weakref
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, cast
@@ -62,6 +63,35 @@ class AppScript:
         else:
             self.name = name
         self.path: Path = Path(self.name).resolve()
+        if self.path.is_dir():
+            self.type = AppType.DIRECTORY
+            # resolve the directory, because Path("file").parent.parent == "." != ".."
+            self.directory = self.path.resolve()
+        elif self.name.endswith(".py"):
+            self.type = AppType.SCRIPT
+            self.directory = self.path.parent.resolve()
+        elif self.name.endswith(".ipynb"):
+            self.type = AppType.NOTEBOOK
+            self.directory = self.path.parent.resolve()
+        else:
+            self.type = AppType.MODULE
+            try:
+                spec = importlib.util.find_spec(self.name)
+            except ValueError:
+                if self.name not in sys.modules:
+                    raise ImportError(f"Module {self.name} not found")
+                spec = importlib.util.spec_from_file_location(self.name, sys.modules[self.name].__file__)
+            if spec is None:
+                raise ImportError(f"Module {self.name} cannot be found")
+            assert spec is not None
+            if spec.origin is None:
+                raise ImportError(f"Module {self.name} cannot be found, or is a namespace package")
+            assert spec.origin is not None
+            self.path = Path(spec.origin)
+            self.directory = self.path.parent
+        self._initialized = False
+
+    def init(self):
         try:
             context = kernel_context.get_current_context()
         except RuntimeError:
@@ -84,6 +114,7 @@ class AppScript:
                 package_root_path = Path(mod.__file__).parent
                 reload.reloader.root_path = package_root_path
         dummy_kernel_context.close()
+        self._initialized = True
 
     def _execute(self):
         logger.info("Executing %s", self.name)
@@ -97,10 +128,8 @@ class AppScript:
                 if working_directory not in sys.path:
                     sys.path.insert(0, working_directory)
 
-        if self.path.is_dir():
-            self.type = AppType.DIRECTORY
+        if self.type == AppType.DIRECTORY:
             # resolve the directory, because Path("file").parent.parent == "." != ".."
-            self.directory = self.path.resolve()
             routes = solara.generate_routes_directory(self.path)
 
             if any(name for name in sys.modules.keys() if name.startswith(self.name)):
@@ -110,45 +139,26 @@ class AppScript:
                     "can avoid this ambiguity."
                 )
 
-        elif self.name.endswith(".py"):
-            self.type = AppType.SCRIPT
+        elif self.type == AppType.SCRIPT:
             add_path()
             # manually add the script to the watcher
             reload.reloader.watcher.add_file(self.path)
-            self.directory = self.path.parent.resolve()
             initial_namespace = {
                 "__name__": "__main__",
             }
             with reload.reloader.watch():
                 routes = [solara.autorouting._generate_route_path(self.path, first=True, initial_namespace=initial_namespace)]
-        elif self.name.endswith(".ipynb"):
-            self.type = AppType.NOTEBOOK
+        elif self.type == AppType.NOTEBOOK:
             add_path()
             # manually add the notebook to the watcher
             reload.reloader.watcher.add_file(self.path)
-            self.directory = self.path.parent.resolve()
             with reload.reloader.watch():
                 routes = [solara.autorouting._generate_route_path(self.path, first=True)]
         else:
             # the module itself will be added by reloader
             # automatically
-            with reload.reloader.watch():
+            with kernel_context.without_context(), reload.reloader.watch():
                 self.type = AppType.MODULE
-                try:
-                    spec = importlib.util.find_spec(self.name)
-                except ValueError:
-                    if self.name not in sys.modules:
-                        raise ImportError(f"Module {self.name} not found")
-                    spec = importlib.util.spec_from_file_location(self.name, sys.modules[self.name].__file__)
-                if spec is None:
-                    raise ImportError(f"Module {self.name} cannot be found")
-                assert spec is not None
-                if spec.origin is None:
-                    raise ImportError(f"Module {self.name} cannot be found, or is a namespace package")
-                assert spec.origin is not None
-                self.path = Path(spec.origin)
-                self.directory = self.path.parent
-
                 mod = importlib.import_module(self.name)
                 routes = solara.generate_routes(mod)
 
@@ -213,7 +223,12 @@ class AppScript:
         for context in context_values:
             context.close()
 
+    def check(self):
+        if not self._initialized:
+            raise RuntimeError("Call solara.server.app.ensure_apps_initialized() first")
+
     def run(self):
+        self.check()
         if reload.reloader.requires_reload or self._first_execute_app is None:
             with thread_lock:
                 if reload.reloader.requires_reload or self._first_execute_app is None:
@@ -420,6 +435,9 @@ def solara_comm_target(comm, msg_first):
 
     def on_msg(msg):
         nonlocal app
+        comm = comm_ref()
+        assert comm is not None
+        context = kernel_context.get_current_context()
         data = msg["content"]["data"]
         method = data["method"]
         if method == "run":
@@ -435,7 +453,12 @@ def solara_comm_target(comm, msg_first):
             themes = args.get("themes")
             dark = args.get("dark")
             load_themes(themes, dark)
-            load_app_widget(None, app, path)
+            try:
+                load_app_widget(None, app, path)
+            except Exception as e:
+                msg = f"Error loading app: from path {path} and app {app_name}"
+                logger.exception(msg)
+                raise RuntimeError(msg) from e
             comm.send({"method": "finished", "widget_id": context.container._model_id})
         elif method == "app-status":
             context = kernel_context.get_current_context()
@@ -464,9 +487,10 @@ def solara_comm_target(comm, msg_first):
         else:
             logger.error("Unknown comm method called on solara.control comm: %s", method)
 
-    comm.on_msg(on_msg)
-
     def reload():
+        comm = comm_ref()
+        assert comm is not None
+        context = kernel_context.get_current_context()
         # we don't reload the app ourself, we send a message to the client
         # this ensures that we don't run code of any client that for some reason is connected
         # but not working anymore. And it indirectly passes a message from the current thread
@@ -474,8 +498,11 @@ def solara_comm_target(comm, msg_first):
         logger.debug(f"Send reload to client: {context.id}")
         comm.send({"method": "reload"})
 
-    context = kernel_context.get_current_context()
-    context.reload = reload
+    comm.on_msg(on_msg)
+    comm_ref = weakref.ref(comm)
+    del comm
+
+    kernel_context.get_current_context().reload = reload
 
 
 def register_solara_comm_target(kernel: Kernel):
@@ -489,3 +516,9 @@ patch.patch()
 if "SOLARA_APP" in os.environ:
     with pdb_guard():
         apps["__default__"] = AppScript(os.environ.get("SOLARA_APP", "solara.website.pages:Page"))
+
+
+@solara.util.once
+def ensure_apps_initialized():
+    for app in apps.values():
+        app.init()

solara/server/flask.py

@@ -65,11 +65,17 @@ class WebsocketWrapper(websocket.WebsocketWrapper):
 
     def send_text(self, data: str) -> None:
         with self.lock:
-            self.ws.send(data)
+            try:
+                self.ws.send(data)
+            except simple_websocket.ws.ConnectionClosed:
+                raise websocket.WebSocketDisconnect()
 
     def send_bytes(self, data: bytes) -> None:
         with self.lock:
-            self.ws.send(data)
+            try:
+                self.ws.send(data)
+            except simple_websocket.ws.ConnectionClosed:
+                raise websocket.WebSocketDisconnect()
 
     async def receive(self):
         from anyio import to_thread
@@ -285,3 +291,7 @@ if has_solara_enterprise:
 
 if __name__ == "__main__":
     app.run(debug=False, port=8765)
+
+# we can only call this at the module level, which means that the solara script cannot import this
+# module. This is a difference with the asgi standard, which provides a lifecycle hook (see starlette.py)
+appmod.ensure_apps_initialized()

solara/server/jupyter/server_extension.py

@@ -14,6 +14,7 @@ def _load_jupyter_server_extension(server_app):
     import solara.server.app
 
     solara.server.app.apps["__default__"] = solara.server.app.AppScript("solara.server.jupyter.solara:Page")
+    solara.server.app.apps["__default__"].init()
 
     web_app = server_app.web_app
 

solara/server/kernel.py

@@ -54,7 +54,7 @@ def json_default(obj):
         import numpy as np
 
         if isinstance(obj, np.number):
-            return repr(obj.item())
+            return obj.item()
         else:
             raise TypeError("%r is not JSON serializable" % obj)
     else:
@@ -215,8 +215,20 @@ def send_websockets(websockets: Set[websocket.WebsocketWrapper], binary_msg):
     for ws in list(websockets):
         try:
             ws.send(binary_msg)
-        except:  # noqa
-            # in case of any issue, we simply remove it from the list
+        except websocket.WebSocketDisconnect:
+            # ignore the exception, we tried to send while websocket closed
+            # just remove it from the websocket set
+            try:
+                # websocket can be modified by another thread
+                websockets.remove(ws)
+            except KeyError:
+                pass  # already removed
+        except Exception as e:  # noqa
+            logger.exception("Error sending message: %s, closing websocket", e)
+            try:
+                ws.close()
+            except Exception as e:  # noqa
+                logger.exception("Error closing websocket: %s", e)
             try:
                 # websocket can be modified by another thread
                 websockets.remove(ws)
@@ -248,6 +260,8 @@ class SessionWebsocket(session.Session):
         header=None,
         metadata=None,
     ):
+        if stream is None:
+            return  # can happen when the kernel is closed but someone was still trying to send a message
         try:
             if isinstance(msg_or_type, dict):
                 msg = msg_or_type
@@ -314,6 +328,39 @@ class Kernel(ipykernel.kernelbase.Kernel):
         self.shell.display_pub.session = self.session
         self.shell.display_pub.pub_socket = self.iopub_socket
 
+    def close(self):
+        if self.comm_manager is None:
+            raise RuntimeError("Kernel already closed")
+        self.session.close()
+        self._cleanup_references()
+
+    def _cleanup_references(self):
+        try:
+            # all of these reduce the circular references
+            # making it easier for the garbage collector to clean up
+            self.shell_handlers.clear()
+            self.control_handlers.clear()
+            for comm_object in list(self.comm_manager.comms.values()):  # type: ignore
+                comm_object.close()
+            self.comm_manager.targets.clear()  # type: ignore
+            # self.comm_manager.kernel points to us, but we cannot set it to None
+            # so we remove the circular reference by setting the comm_manager to None
+            self.comm_manager = None  # type: ignore
+            self.session.parent = None  # type: ignore
+
+            self.shell.display_pub.session = None  # type: ignore
+            self.shell.display_pub.pub_socket = None  # type: ignore
+            del self.shell.__dict__
+            self.shell = None  # type: ignore
+            self.session.websockets.clear()
+            self.session.stream = None  # type: ignore
+            self.session = None  # type: ignore
+            self.stream.session = None  # type: ignore
+            self.stream = None  # type: ignore
+            self.iopub_socket = None  # type: ignore
+        except Exception:
+            logger.exception("Error cleaning up references from kernel, not fatal")
+
     async def _flush_control_queue(self):
         pass
 

solara/server/kernel_context.py

@@ -6,6 +6,8 @@ try:
 except ModuleNotFoundError:
     contextvars = None  # type: ignore
 
+import concurrent.futures
+import contextlib
 import dataclasses
 import enum
 import logging
@@ -71,6 +73,7 @@ class VirtualKernelContext:
     page_status: Dict[str, PageStatus] = dataclasses.field(default_factory=dict)
     # only used for testing
     _last_kernel_cull_task: "Optional[asyncio.Future[None]]" = None
+    _last_kernel_cull_future: "Optional[concurrent.futures.Future[None]]" = None
     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)
@@ -112,6 +115,10 @@ class VirtualKernelContext:
         with self, self.lock:
             for key in self.page_status:
                 self.page_status[key] = PageStatus.CLOSED
+            if self._last_kernel_cull_task:
+                self._last_kernel_cull_task.cancel()
+            if self._last_kernel_cull_future:
+                self._last_kernel_cull_future.cancel()
             if self.closed_event.is_set():
                 logger.error("Tried to close a kernel context that is already closed: %s", self.id)
                 return
@@ -129,9 +136,18 @@ class VirtualKernelContext:
             # what if we reference each other
             # import gc
             # gc.collect()
-            self.kernel.session.close()
+            self.kernel.close()
+            self.kernel = None  # type: ignore
             if self.id in contexts:
                 del contexts[self.id]
+            del current_context[get_current_thread_key()]
+            # We saw in memleak_test that there are sometimes other entries in current_context
+            # In which _DummyThread's reference this context, so we remove those references too
+            # TODO: Think about what to do with those Threads
+            _contexts = current_context.copy()
+            for key, _ctx in _contexts.items():
+                if _ctx is self:
+                    del current_context[key]
             self.closed_event.set()
 
     def _state_reset(self):
@@ -158,6 +174,8 @@ class VirtualKernelContext:
                 pickle.dump(state, f)
 
     def page_connect(self, page_id: str):
+        if self.closed_event.is_set():
+            raise RuntimeError("Cannot connect a page to a closed kernel")
         logger.info("Connect page %s for kernel %s", page_id, self.id)
         with self.lock:
             if self.closed_event.is_set():
@@ -184,13 +202,19 @@ class VirtualKernelContext:
                         logger.info("No connected pages, and timeout reached, shutting down virtual kernel %s", self.id)
                         self.close()
                 if current_event_loop is not None and future is not None:
-                    current_event_loop.call_soon_threadsafe(future.set_result, None)
+                    try:
+                        current_event_loop.call_soon_threadsafe(future.set_result, None)
+                    except RuntimeError:
+                        pass  # event loop already closed, happens during testing
             except asyncio.CancelledError:
                 if current_event_loop is not None and future is not None:
-                    if sys.version_info >= (3, 9):
-                        current_event_loop.call_soon_threadsafe(future.cancel, "cancelled because a new cull task was scheduled")
-                    else:
-                        current_event_loop.call_soon_threadsafe(future.cancel)
+                    try:
+                        if sys.version_info >= (3, 9):
+                            current_event_loop.call_soon_threadsafe(future.cancel, "cancelled because a new cull task was scheduled")
+                        else:
+                            current_event_loop.call_soon_threadsafe(future.cancel)
+                    except RuntimeError:
+                        pass  # event loop already closed, happens during testing
                 raise
 
         async def create_task():
@@ -212,7 +236,17 @@ class VirtualKernelContext:
                 self._last_kernel_cull_task.cancel()
 
             logger.info("Scheduling kernel cull for virtual kernel %s", self.id)
-            asyncio.run_coroutine_threadsafe(create_task(), keep_alive_event_loop)
+
+            async def create_task():
+                task = asyncio.create_task(kernel_cull())
+                # create a reference to the task so we can cancel it later
+                self._last_kernel_cull_task = task
+                try:
+                    await task
+                except RuntimeError:
+                    pass  # event loop already closed, happens during testing
+
+            self._last_kernel_cull_future = asyncio.run_coroutine_threadsafe(create_task(), keep_alive_event_loop)
             return future
 
     def page_disconnect(self, page_id: str) -> "Optional[asyncio.Future[None]]":
@@ -259,7 +293,12 @@ class VirtualKernelContext:
             pass
         else:
             future.set_result(None)
+
+        logger.info("page status: %s", self.page_status)
         with self.lock:
+            if self.closed_event.is_set():
+                logger.info("Kernel %s was already closed when page %s attempted to close", self.id, page_id)
+                return
             if self.page_status[page_id] == PageStatus.CLOSED:
                 logger.info("Page %s already closed for kernel %s", page_id, self.id)
                 return
@@ -351,6 +390,11 @@ def set_context_for_thread(context: VirtualKernelContext, thread: threading.Thre
     current_context[key] = context
 
 
+def clear_context_for_thread(thread: threading.Thread):
+    key = get_thread_key(thread)
+    current_context.pop(key, None)
+
+
 def has_current_context() -> bool:
     thread_key = get_current_thread_key()
     return (thread_key in current_context) and (current_context[thread_key] is not None)
@@ -377,6 +421,21 @@ def set_current_context(context: Optional[VirtualKernelContext]):
     current_context[thread_key] = context
 
 
+@contextlib.contextmanager
+def without_context():
+    context = None
+    try:
+        context = get_current_context()
+    except RuntimeError:
+        pass
+    thread_key = get_current_thread_key()
+    current_context[thread_key] = None
+    try:
+        yield
+    finally:
+        current_context[thread_key] = context
+
+
 def initialize_virtual_kernel(session_id: str, kernel_id: str, websocket: websocket.WebsocketWrapper):
     from solara.server import app as appmodule
 

solara/server/patch.py

@@ -1,4 +1,3 @@
-import functools
 import logging
 import os
 import pdb
@@ -15,6 +14,9 @@ import ipywidgets
 import ipywidgets.widgets.widget_output
 from IPython.core.interactiveshell import InteractiveShell
 
+import solara
+import solara.util
+
 from . import app, kernel_context, reload, settings
 from .utils import pdb_guard
 
@@ -39,6 +41,7 @@ class FakeIPython:
         # (although we don't really support it)
         self.events = mock.MagicMock()
         self.user_ns: Dict[Any, Any] = {}
+        self.custom_exceptions = ()
 
     def enable_gui(self, gui):
         logger.error("ignoring call to enable_gui(%s)", gui)
@@ -249,7 +252,8 @@ def auto_watch_get_template(get_template):
 
     def wrapper(abs_path):
         template = get_template(abs_path)
-        reload.reloader.watcher.add_file(abs_path)
+        with kernel_context.without_context():
+            reload.reloader.watcher.add_file(abs_path)
         return template
 
     return wrapper
@@ -272,10 +276,13 @@ def WidgetContextAwareThread__init__(self, *args, **kwargs):
         ThreadDebugInfo.created += 1
 
     self.current_context = None
-    try:
-        self.current_context = kernel_context.get_current_context()
-    except RuntimeError:
-        logger.debug(f"No context for thread {self}")
+    # if we do this for the dummy threads, we got into a recursion
+    # since threading.current_thread will call the _DummyThread constructor
+    if not ("name" in kwargs and "Dummy-" in kwargs["name"]):
+        try:
+            self.current_context = kernel_context.get_current_context()
+        except RuntimeError:
+            logger.debug(f"No context for thread {self._name}")
 
 
 def WidgetContextAwareThread__bootstrap(self):
@@ -291,6 +298,7 @@ def WidgetContextAwareThread__bootstrap(self):
 
 def _WidgetContextAwareThread__bootstrap(self):
     if not hasattr(self, "current_context"):
+        # this happens when a thread was running before we patched
         return Thread__bootstrap(self)
     if self.current_context:
         # we need to call this manually, because set_context_for_thread
@@ -299,15 +307,20 @@ def _WidgetContextAwareThread__bootstrap(self):
         if kernel_context.async_context_id is not None:
             kernel_context.async_context_id.set(self.current_context.id)
         kernel_context.set_context_for_thread(self.current_context, self)
-
         shell = self.current_context.kernel.shell
-        shell.display_pub.register_hook(shell.display_in_reacton_hook)
+        display_pub = shell.display_pub
+        display_in_reacton_hook = shell.display_in_reacton_hook
+        display_pub.register_hook(display_in_reacton_hook)
     try:
-        with pdb_guard():
+        context = self.current_context or solara.util.nullcontext()
+        with pdb_guard(), context:
             Thread__bootstrap(self)
     finally:
-        if self.current_context:
-            shell.display_pub.unregister_hook(shell.display_in_reacton_hook)
+        current_context = self.current_context
+        self.current_context = None
+        kernel_context.clear_context_for_thread(self)
+        if current_context:
+            display_pub.unregister_hook(display_in_reacton_hook)
 
 
 _patched = False
@@ -354,24 +367,7 @@ def patch_ipyreact():
     ipyreact.importmap._update_import_map = lambda: None
 
 
-def once(f):
-    called = False
-    return_value = None
-
-    @functools.wraps(f)
-    def wrapper():
-        nonlocal called
-        nonlocal return_value
-        if called:
-            return return_value
-        called = True
-        return_value = f()
-        return return_value
-
-    return wrapper
-
-
-@once
+@solara.util.once
 def patch_matplotlib():
     import matplotlib
     import matplotlib._pylab_helpers

solara/server/server.py

@@ -16,6 +16,7 @@ import requests
 import solara
 import solara.routing
 import solara.settings
+import solara.server.settings
 from solara.lab import cookies as solara_cookies
 from solara.lab import headers as solara_headers
 
@@ -66,6 +67,8 @@ nbextensions_ignorelist = [
     "jupyter-js/extension",
     "jupyter-js-widgets/extension",
     "jupyter_dash/main",
+    "dash/main",
+    *solara.server.settings.server.ignore_nbextensions,
 ]
 
 
@@ -157,7 +160,8 @@ async def app_loop(
                     message = await ws.receive()
                 except websocket.WebSocketDisconnect:
                     try:
-                        context.kernel.session.websockets.remove(ws)
+                        if context.kernel is not None and context.kernel.session is not None:
+                            context.kernel.session.websockets.remove(ws)
                     except KeyError:
                         pass
                     logger.debug("Disconnected")
@@ -168,10 +172,15 @@ async def app_loop(
                 else:
                     msg = deserialize_binary_message(message)
                 t1 = time.time()
-                if not process_kernel_messages(kernel, msg):
-                    # if we shut down the kernel, we do not keep the page session alive
-                    context.close()
-                    return
+                # we don't want to have the kernel closed while we are processing a message
+                # therefore we use this mutex that is also used in the context.close method
+                with context.lock:
+                    if context.closed_event.is_set():
+                        return
+                    if not process_kernel_messages(kernel, msg):
+                        # if we shut down the kernel, we do not keep the page session alive
+                        context.close()
+                        return
                 t2 = time.time()
                 if settings.main.timing:
                     widgets_ids_after = set(patch.widgets)
@@ -282,6 +291,7 @@ def read_root(
             return content
 
     default_app = app.apps["__default__"]
+    default_app.check()
     routes = default_app.routes
     router = solara.routing.Router(path, routes)
     if not router.possible_match:

solara/server/settings.py

@@ -132,6 +132,7 @@ OAUTH_TEST_CLIENT_IDs = [AUTH0_TEST_CLIENT_ID, FIEF_TEST_CLIENT_ID]
 
 class Session(BaseSettings):
     secret_key: str = SESSION_SECRET_KEY_DEFAULT
+    http_only: bool = False
     https_only: Optional[bool] = None
     same_site: str = "lax"
 
@@ -163,6 +164,15 @@ if is_mac_os_conda or is_wsl_windows:
     HOST_DEFAULT = "localhost"
 
 
+class Server(BaseSettings):
+    ignore_nbextensions: List[str] = []
+
+    class Config:
+        env_prefix = "solara_server_"
+        case_sensitive = False
+        env_file = ".env"
+
+
 class MainSettings(BaseSettings):
     use_pdb: bool = False
     mode: str = "production"
@@ -181,6 +191,7 @@ class MainSettings(BaseSettings):
 
 
 main = MainSettings()
+server = Server()
 theme = ThemeSettings()
 telemetry = Telemetry()
 ssg = SSG()

solara/server/shell.py

@@ -1,3 +1,4 @@
+import atexit
 import io
 import sys
 from binascii import b2a_base64
@@ -58,9 +59,12 @@ class SolaraDisplayPublisher(DisplayPublisher):
         self,
         data,
         metadata=None,
+        source=None,
+        *,  # Enforce keyword-only arguments to match DisplayPublisher.publish
         transient=None,
         update=False,
-    ):
+        **kwargs,  # Make sure we're compatible with DisplayPublisher.publish
+    ) -> None:
         """Publish a display-data message
 
         Parameters
@@ -180,10 +184,24 @@ class SolaraInteractiveShell(InteractiveShell):
     history_manager = Any()  # type: ignore
     display_pub: SolaraDisplayPublisher
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        atexit.unregister(self.atexit_operations)
+
+        if self.magics_manager:
+            magic = self.magics_manager.registry["ScriptMagics"]
+            atexit.unregister(magic.kill_bg_processes)
+
     def set_parent(self, parent):
         """Tell the children about the parent message."""
         self.display_pub.set_parent(parent)
 
+    def init_sys_modules(self):
+        pass  # don't create a __main__, it will cause a mem leak
+
+    def init_prefilter(self):
+        pass  # avoid consuming memory
+
     def init_history(self):
         self.history_manager = Mock()  # type: ignore