Change run_blocking into run_sync

Author: davidbrochart

nbclient/client.py

@@ -16,6 +16,7 @@
 from nbformat.v4 import output_from_msg
 
 from .exceptions import CellTimeoutError, DeadKernelError, CellExecutionComplete, CellExecutionError
+from .util import run_sync
 
 
 def timestamp():
@@ -294,43 +295,6 @@ def __init__(self, nb, km=None, **kw):
         self.km = km
         self.reset_execution_trackers()
 
-    def run_blocking(self, coro):
-        """Runs a coroutine and blocks until it has executed.
-
-        An event loop is created if no one already exists. If an event loop is
-        already running, this event loop execution is nested into the already
-        running one if `nest_asyncio` is set to True.
-
-        Parameters
-        ----------
-        coro : coroutine
-            The coroutine to be executed.
-
-        Returns
-        -------
-        result :
-            Whatever the coroutine returns.
-        """
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        if self.nest_asyncio:
-            import nest_asyncio
-            nest_asyncio.apply(loop)
-        try:
-            result = loop.run_until_complete(coro)
-        except RuntimeError as e:
-            if str(e) == 'This event loop is already running':
-                raise RuntimeError(
-                    'You are trying to run nbclient in an environment where an '
-                    'event loop is already running. Please pass `nest_asyncio=True` in '
-                    '`NotebookClient.execute` and such methods.'
-                )
-            raise
-        return result
-
     def reset_execution_trackers(self):
         """Resets any per-execution trackers.
         """
@@ -417,9 +381,6 @@ async def setup_kernel(self, **kwargs):
             self.kc.stop_channels()
             self.kc = None
 
-    def execute(self, **kwargs):
-        return self.run_blocking(self.async_execute(**kwargs))
-
     async def async_execute(self, **kwargs):
         """
         Executes each code cell.
@@ -445,6 +406,8 @@ async def async_execute(self, **kwargs):
 
         return self.nb
 
+    execute = run_sync(async_execute)
+
     def set_widgets_metadata(self):
         if self.widget_state:
             self.nb.metadata.widgets = {
@@ -591,11 +554,6 @@ def _check_raise_for_error(self, cell, exec_reply):
             if (exec_reply is not None) and exec_reply['content']['status'] == 'error':
                 raise CellExecutionError.from_cell_and_msg(cell, exec_reply['content'])
 
-    def execute_cell(self, cell, cell_index, execution_count=None, store_history=True):
-        return self.run_blocking(
-            self.async_execute_cell(cell, cell_index, execution_count, store_history)
-        )
-
     async def async_execute_cell(self, cell, cell_index, execution_count=None, store_history=True):
         """
         Executes a single code cell.
@@ -661,6 +619,8 @@ async def async_execute_cell(self, cell, cell_index, execution_count=None, store
         self.nb['cells'][cell_index] = cell
         return cell
 
+    execute_cell = run_sync(async_execute_cell)
+
     def process_message(self, msg, cell, cell_index):
         """
         Processes a kernel message, updates cell state, and returns the

nbclient/tests/test_client.py

@@ -492,7 +492,7 @@ def test_kernel_death(self):
         km = executor.start_kernel_manager()
 
         with patch.object(km, "is_alive") as alive_mock:
-            alive_mock.return_value = make_async(False)
+            alive_mock.return_value = False
             # Will be a RuntimeError or subclass DeadKernelError depending
             # on if jupyter_client or nbconvert catches the dead client first
             with pytest.raises(RuntimeError):

nbclient/util.py

@@ -0,0 +1,47 @@
+"""General utility methods"""
+
+# Copyright (c) Jupyter Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import asyncio
+
+
+def run_sync(coro):
+    """Runs a coroutine and blocks until it has executed.
+
+    An event loop is created if no one already exists. If an event loop is
+    already running, this event loop execution is nested into the already
+    running one if `nest_asyncio` is set to True.
+
+    Parameters
+    ----------
+    coro : coroutine
+        The coroutine to be executed.
+
+    Returns
+    -------
+    result :
+        Whatever the coroutine returns.
+    """
+    def wrapped(self, *args, **kwargs):
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        if self.nest_asyncio:
+            import nest_asyncio
+            nest_asyncio.apply(loop)
+        try:
+            result = loop.run_until_complete(coro(self, *args, **kwargs))
+        except RuntimeError as e:
+            if str(e) == 'This event loop is already running':
+                raise RuntimeError(
+                    'You are trying to run nbclient in an environment where an '
+                    'event loop is already running. Please pass `nest_asyncio=True` in '
+                    '`NotebookClient.execute` and such methods.'
+                )
+            raise
+        return result
+    wrapped.__doc__ = coro.__doc__
+    return wrapped