Enable async JupyterApp (#381)

* Enable async app

* improve the test

* fix async handling

* fix typing

Author: blink1073

jupyter_core/application.py

@@ -29,7 +29,7 @@
     jupyter_path,
     jupyter_runtime_dir,
 )
-from .utils import ensure_dir_exists
+from .utils import ensure_dir_exists, get_event_loop
 
 # mypy: disable-error-code="no-untyped-call"
 
@@ -259,6 +259,11 @@ def initialize(self, argv: t.Any = None) -> None:
         self.update_config(cl_config)
         if allow_insecure_writes:
             issue_insecure_write_warning()
+        return
+
+    async def initialize_async(self) -> None:
+        """Perform async initialization of the application, will be called
+        after synchronous initialize."""
 
     def start(self) -> None:
         """Start the whole thing"""
@@ -274,14 +279,33 @@ def start(self) -> None:
             self.write_default_config()
             raise NoStart()
 
+        return
+
+    async def start_async(self) -> None:
+        """Perform async start of the app, will be called after sync start."""
+
     @classmethod
-    def launch_instance(cls, argv: t.Any = None, **kwargs: t.Any) -> None:
-        """Launch an instance of a Jupyter Application"""
+    async def _async_launch_instance(cls, argv: t.Any = None, **kwargs: t.Any) -> None:
+        """Launch the instance from inside an event loop."""
         try:
-            super().launch_instance(argv=argv, **kwargs)
+            app = cls.instance(**kwargs)
+            app.initialize(argv)
+            await app.initialize_async()
+            app.start()
+            await app.start_async()
         except NoStart:
             return
 
+    @classmethod
+    def launch_instance(cls, argv: t.Any = None, **kwargs: t.Any) -> None:
+        """Launch a global instance of this Application
+
+        If a global instance already exists, this reinitializes and starts it
+        """
+        loop = get_event_loop()
+        coro = cls._async_launch_instance(argv, **kwargs)
+        loop.run_until_complete(coro)
+
 
 if __name__ == "__main__":
     JupyterApp.launch_instance()

jupyter_core/utils/__init__.py

@@ -158,18 +158,8 @@ def wrapped(*args: Any, **kwargs: Any) -> Any:
         except RuntimeError:
             pass
 
-        # Run the loop for this thread.
-        # In Python 3.12, a deprecation warning is raised, which
-        # may later turn into a RuntimeError.  We handle both
-        # cases.
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            try:
-                loop = asyncio.get_event_loop()
-            except RuntimeError:
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-            return loop.run_until_complete(inner)
+        loop = get_event_loop()
+        return loop.run_until_complete(inner)
 
     wrapped.__doc__ = coro.__doc__
     return wrapped
@@ -194,3 +184,21 @@ async def ensure_async(obj: Awaitable[T] | T) -> T:
         return result
     # obj doesn't need to be awaited
     return cast(T, obj)
+
+
+def get_event_loop() -> asyncio.AbstractEventLoop:
+    # Get the loop for this thread.
+    # In Python 3.12, a deprecation warning is raised, which
+    # may later turn into a RuntimeError.  We handle both
+    # cases.
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            if sys.platform == "win32":
+                loop = asyncio.WindowsSelectorEventLoopPolicy().new_event_loop()
+            else:
+                loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+    return loop

tests/test_application.py

@@ -125,3 +125,17 @@ def test_runtime_dir_changed():
     app.runtime_dir = td
     assert os.path.isdir(td)
     shutil.rmtree(td)
+
+
+class AsyncApp(JupyterApp):
+    async def initialize_async(self):
+        self.value = 10
+
+    async def start_async(self):
+        assert self.value == 10
+
+
+def test_async_app():
+    AsyncApp.launch_instance([])
+    app = AsyncApp.instance()
+    assert app.value == 10