Change BlockingKernelManager back to KernelManager

Author: davidbrochart

jupyter_client/__init__.py

@@ -4,7 +4,7 @@
 from .connect import *
 from .launcher import *
 from .client import KernelClient
-from .manager import KernelManager, BlockingKernelManager, AsyncKernelManager, run_kernel
+from .manager import KernelManager, AsyncKernelManager, run_kernel
 from .blocking import BlockingKernelClient
 from .asynchronous import AsyncKernelClient
 from .multikernelmanager import MultiKernelManager, AsyncMultiKernelManager

jupyter_client/consoleapp.py

@@ -25,7 +25,7 @@
 
 from .blocking import BlockingKernelClient
 from .restarter import KernelRestarter
-from . import BlockingKernelManager, tunnel_to_kernel, find_connection_file, connect
+from . import KernelManager, tunnel_to_kernel, find_connection_file, connect
 from .kernelspec import NoSuchKernel
 from .session import Session
 
@@ -86,7 +86,7 @@
 # Classes
 #-----------------------------------------------------------------------------
 
-classes = [BlockingKernelManager, KernelRestarter, Session]
+classes = [KernelManager, KernelRestarter, Session]
 
 class JupyterConsoleApp(ConnectionFileMixin):
     name = 'jupyter-console-mixin'
@@ -112,7 +112,7 @@ class JupyterConsoleApp(ConnectionFileMixin):
     flags = Dict(flags)
     aliases = Dict(aliases)
     kernel_manager_class = Type(
-        default_value=BlockingKernelManager,
+        default_value=KernelManager,
         config=True,
         help='The kernel manager class to use.'
     )

jupyter_client/kernelapp.py

@@ -8,15 +8,15 @@
 
 from . import __version__
 from .kernelspec import KernelSpecManager, NATIVE_KERNEL_NAME
-from .manager import BlockingKernelManager
+from .manager import KernelManager
 
 class KernelApp(JupyterApp):
     """Launch a kernel by name in a local subprocess.
     """
     version = __version__
     description = "Run a kernel locally in a subprocess"
 
-    classes = [BlockingKernelManager, KernelSpecManager]
+    classes = [KernelManager, KernelSpecManager]
 
     aliases = {
         'kernel': 'KernelApp.kernel_name',
@@ -33,8 +33,8 @@ def initialize(self, argv=None):
 
         cf_basename = 'kernel-%s.json' % uuid.uuid4()
         self.config.setdefault('KernelManager', {}).setdefault('connection_file', os.path.join(self.runtime_dir, cf_basename))
-        self.km = BlockingKernelManager(kernel_name=self.kernel_name,
-                                        config=self.config)
+        self.km = KernelManager(kernel_name=self.kernel_name,
+                                config=self.config)
 
         self.loop = IOLoop.current()
         self.loop.add_callback(self._record_started)

jupyter_client/manager.py

@@ -283,7 +283,7 @@ async def _async__launch_kernel(
         """
         return launch_kernel(kernel_cmd, **kw)
 
-    _launch_kernel = _async__launch_kernel
+    _launch_kernel = run_sync(_async__launch_kernel)
 
     # Control socket used for polite kernel shutdown
 
@@ -383,7 +383,7 @@ async def _async_start_kernel(self, **kw):
         self.kernel = await self._async__launch_kernel(kernel_cmd, **kw)
         self.post_start_kernel(**kw)
 
-    start_kernel = _async_start_kernel
+    start_kernel = run_sync(_async_start_kernel)
 
     def request_shutdown(
         self,
@@ -433,7 +433,7 @@ async def _async_finish_shutdown(
                 self.kernel.wait()
                 self.kernel = None
 
-    finish_shutdown = _async_finish_shutdown
+    finish_shutdown = run_sync(_async_finish_shutdown)
 
     def cleanup_resources(
         self,
@@ -517,7 +517,7 @@ async def _async_shutdown_kernel(
         else:
             self.cleanup_resources(restart=restart)
 
-    shutdown_kernel = _async_shutdown_kernel
+    shutdown_kernel = run_sync(_async_shutdown_kernel)
 
     async def _async_restart_kernel(
         self,
@@ -563,7 +563,7 @@ async def _async_restart_kernel(
             self._launch_args.update(kw)
             await self._async_start_kernel(**self._launch_args)
 
-    restart_kernel = _async_restart_kernel
+    restart_kernel = run_sync(_async_restart_kernel)
 
     @property
     def has_kernel(self) -> bool:
@@ -600,7 +600,7 @@ async def _async__send_kernel_sigterm(self) -> None:
                     if e.errno != ESRCH:
                         raise
 
-    _send_kernel_sigterm = _async__send_kernel_sigterm
+    _send_kernel_sigterm = run_sync(_async__send_kernel_sigterm)
 
     async def _async__kill_kernel(self) -> None:
         """Kill the running kernel.
@@ -641,7 +641,7 @@ async def _async__kill_kernel(self) -> None:
                     self.kernel.wait()
             self.kernel = None
 
-    _kill_kernel = _async__kill_kernel
+    _kill_kernel = run_sync(_async__kill_kernel)
 
     async def _async_interrupt_kernel(self) -> None:
         """Interrupts the kernel by sending it a signal.
@@ -666,7 +666,7 @@ async def _async_interrupt_kernel(self) -> None:
         else:
             raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
 
-    interrupt_kernel = _async_interrupt_kernel
+    interrupt_kernel = run_sync(_async_interrupt_kernel)
 
     async def _async_signal_kernel(
         self,
@@ -691,7 +691,7 @@ async def _async_signal_kernel(
         else:
             raise RuntimeError("Cannot signal kernel. No kernel is running!")
 
-    signal_kernel = _async_signal_kernel
+    signal_kernel = run_sync(_async_signal_kernel)
 
     async def _async_is_alive(self) -> bool:
         """Is the kernel process still running?"""
@@ -704,7 +704,7 @@ async def _async_is_alive(self) -> bool:
             # we don't have a kernel
             return False
 
-    is_alive = _async_is_alive
+    is_alive = run_sync(_async_is_alive)
 
     async def _async_wait(
         self,
@@ -718,23 +718,22 @@ async def _async_wait(
             await asyncio.sleep(pollinterval)
 
 
-class BlockingKernelManager(KernelManager):
-    _launch_kernel = run_sync(KernelManager._launch_kernel)
-    start_kernel = run_sync(KernelManager.start_kernel)
-    finish_shutdown = run_sync(KernelManager.finish_shutdown)
-    shutdown_kernel = run_sync(KernelManager.shutdown_kernel)
-    restart_kernel = run_sync(KernelManager.restart_kernel)
-    _send_kernel_sigterm = run_sync(KernelManager._send_kernel_sigterm)
-    _kill_kernel = run_sync(KernelManager._kill_kernel)
-    interrupt_kernel = run_sync(KernelManager.interrupt_kernel)
-    signal_kernel = run_sync(KernelManager.signal_kernel)
-    is_alive = run_sync(KernelManager.is_alive)
-
 class AsyncKernelManager(KernelManager):
     # the class to create with our `client` method
     client_class: DottedObjectName = DottedObjectName('jupyter_client.asynchronous.AsyncKernelClient')
     client_factory: Type = Type(klass='jupyter_client.asynchronous.AsyncKernelClient')
 
+    _launch_kernel = KernelManager._async__launch_kernel
+    start_kernel = KernelManager._async_start_kernel
+    finish_shutdown = KernelManager._async_finish_shutdown
+    shutdown_kernel = KernelManager._async_shutdown_kernel
+    restart_kernel = KernelManager._async_restart_kernel
+    _send_kernel_sigterm = KernelManager._async__send_kernel_sigterm
+    _kill_kernel = KernelManager._async__kill_kernel
+    interrupt_kernel = KernelManager._async_interrupt_kernel
+    signal_kernel = KernelManager._async_signal_kernel
+    is_alive = KernelManager._async_is_alive
+
 
 KernelManagerABC.register(KernelManager)
 
@@ -743,9 +742,9 @@ def start_new_kernel(
     startup_timeout: float =60,
     kernel_name: str = 'python',
     **kwargs
-) -> t.Tuple[BlockingKernelManager, KernelClient]:
+) -> t.Tuple[KernelManager, KernelClient]:
     """Start a new kernel, and return its Manager and Client"""
-    km = BlockingKernelManager(kernel_name=kernel_name)
+    km = KernelManager(kernel_name=kernel_name)
     km.start_kernel(**kwargs)
     kc = km.client()
     kc.start_channels()

jupyter_client/tests/test_kernelmanager.py

@@ -17,7 +17,7 @@
 from async_generator import async_generator, yield_
 from traitlets.config.loader import Config
 from jupyter_core import paths
-from jupyter_client import BlockingKernelManager, AsyncKernelManager
+from jupyter_client import KernelManager, AsyncKernelManager
 from subprocess import PIPE
 
 from ..manager import start_new_kernel, start_new_async_kernel
@@ -101,7 +101,7 @@ def start_kernel():
 
 @pytest.fixture
 def km(config):
-    km = BlockingKernelManager(config=config)
+    km = KernelManager(config=config)
     return km
 
 
@@ -186,7 +186,7 @@ def test_lifecycle(self, km):
         km.restart_kernel(now=True)
         assert km.is_alive()
         km.interrupt_kernel()
-        assert isinstance(km, BlockingKernelManager)
+        assert isinstance(km, KernelManager)
         km.shutdown_kernel(now=True)
         assert km.context.closed
 
@@ -275,7 +275,7 @@ def test_cleanup_context(self, km):
 
     def test_no_cleanup_shared_context(self, zmq_context):
         """kernel manager does not terminate shared context"""
-        km = BlockingKernelManager(context=zmq_context)
+        km = KernelManager(context=zmq_context)
         assert km.context == zmq_context
         assert km.context is not None
 
@@ -349,7 +349,7 @@ def _prepare_kernel(self, km, startup_timeout=TIMEOUT, **kwargs):
         return kc
 
     def _run_signaltest_lifecycle(self, config=None):
-        km = BlockingKernelManager(config=config, kernel_name='signaltest')
+        km = KernelManager(config=config, kernel_name='signaltest')
         kc = self._prepare_kernel(km, stdout=PIPE, stderr=PIPE)
 
         def execute(cmd):

jupyter_client/tests/test_public_api.py

@@ -9,7 +9,7 @@
 
 
 def test_kms():
-    for base in ("", "Blocking", "Async", "Multi"):
+    for base in ("", "Async", "Multi"):
         KM = base + "KernelManager"
         assert KM in dir(jupyter_client)