Add pseudo sync mode

IPython/core/async_helpers.py

@@ -34,7 +34,7 b' def _curio_runner(coroutine):'
     return curio.run(coroutine)
 
 
-def _trio_runner(function):
+def _trio_runner(async_fn):
     import trio
     async def loc(coro):
         """
@@ -42,7 +42,25 b' def _trio_runner(function):'
         trio's internal. See https://github.com/python-trio/trio/issues/89
         """
         return await coro
-    return trio.run(loc, function)
+    return trio.run(loc, async_fn)
+
+
+def _pseudo_sync_runner(coro):
+    """
+    A runner that does not really allow async execution, and just advance the coroutine.
+
+    See discussion in https://github.com/python-trio/trio/issues/608,
+
+    Credit to Nathaniel Smith
+
+    """
+    try:
+        coro.send(None)
+    except StopIteration as exc:
+        return exc.value
+    else:
+        # TODO: do not raise but return an execution result with the right info.
+        raise RuntimeError(f"{coro.__name__!r} needs a real async loop")
 
 
 def _asyncify(code: str) -> str:

IPython/core/interactiveshell.py

@@ -152,7 +152,7 b' def removed_co_newlocals(function:types.FunctionType) -> types.FunctionType:'
 
 # we still need to run things using the asyncio eventloop, but there is no
 # async integration
-from .async_helpers import (_asyncio_runner,  _asyncify)
+from .async_helpers import (_asyncio_runner,  _asyncify, _pseudo_sync_runner)
 
 if sys.version_info > (3, 5):
     from .async_helpers import _curio_runner, _trio_runner, _should_be_async
@@ -365,9 +365,10 b' class InteractiveShell(SingletonConfigurable):'
     ).tag(config=True)
 
     loop_runner_map ={
-        'asyncio':_asyncio_runner,
-        'curio':_curio_runner,
-        'trio':_trio_runner,
+        'asyncio':(_asyncio_runner, True),
+        'curio':(_curio_runner, True),
+        'trio':(_trio_runner, True),
+        'sync': (_pseudo_sync_runner, False)
     }
 
     loop_runner = Any(default_value="IPython.core.interactiveshell._asyncio_runner",
@@ -383,7 +384,9 b' class InteractiveShell(SingletonConfigurable):'
     def _import_runner(self, proposal):
         if isinstance(proposal.value, str):
             if proposal.value in self.loop_runner_map:
-                return self.loop_runner_map[proposal.value]
+                runner, autoawait = self.loop_runner_map[proposal.value]
+                self.autoawait = autoawait
+                return runner
             runner = import_item(proposal.value)
             if not callable(runner):
                 raise ValueError('loop_runner must be callable')
@@ -2815,7 +2818,7 b' class InteractiveShell(SingletonConfigurable):'
         )
 
     @asyncio.coroutine
-    def run_cell_async(self, raw_cell, store_history=False, silent=False, shell_futures=True):
+    def run_cell_async(self, raw_cell:str, store_history=False, silent=False, shell_futures=True) -> ExecutionResult:
         """Run a complete IPython cell asynchronously.
 
         Parameters

IPython/core/magics/basic.py

@@ -622,9 +622,14 b' class AsyncMagics(BasicMagics):'
         - asyncio/curio/trio activate autoawait integration and use integration
           with said library.
 
+        - `sync` turn on the pseudo-sync integration (mostly used for
+          `IPython.embed()` which does not run IPython with a real eventloop and
+          deactivate running asynchronous code. Turning on Asynchronous code with
+          the pseudo sync loop is undefined behavior and may lead IPython to crash.
+
         If the passed parameter does not match any of the above and is a python
         identifier, get said object from user namespace and set it as the
-        runner, and activate autoawait.
+        runner, and activate autoawait. 
 
         If the object is a fully qualified object name, attempt to import it and
         set it as the runner, and activate autoawait."""
@@ -647,8 +652,7 b' class AsyncMagics(BasicMagics):'
             return None
 
         if param in self.shell.loop_runner_map:
-            self.shell.loop_runner = param
-            self.shell.autoawait = True
+            self.shell.loop_runner, self.shell.autoawait = self.shell.loop_runner_map[param]
             return None
 
         if param in self.shell.user_ns :

IPython/terminal/embed.py

@@ -383,9 +383,9 b' def embed(**kwargs):'
         config = load_default_config()
         config.InteractiveShellEmbed = config.TerminalInteractiveShell
         kwargs['config'] = config
-    using = kwargs.get('using', 'trio')
+    using = kwargs.get('using', 'sync')
     if using :
-        kwargs['config'].update({'TerminalInteractiveShell':{'loop_runner':using, 'colors':'NoColor'}})
+        kwargs['config'].update({'TerminalInteractiveShell':{'loop_runner':using, 'colors':'NoColor', 'autoawait': using!='sync'}})
     #save ps1/ps2 if defined
     ps1 = None
     ps2 = None

docs/source/interactive/autoawait.rst

@@ -121,8 +121,15 b' no network request is done between ``In[1]`` and ``In[2]``.'
 Effects on IPython.embed()
 ==========================
 
-IPython core being synchronous, the use of ``IPython.embed()`` will now require
-a loop to run. This affect the ability to nest ``IPython.embed()`` which may
+IPython core being asynchronous, the use of ``IPython.embed()`` will now require
+a loop to run. In order to allow ``IPython.embed()`` to be nested, as most event
+loops can't be nested, ``IPython.embed()`` default to a pseudo-synchronous mode,
+where async code is not allowed. This mode is available in classical IPython
+using ``%autoawait sync``
+
+
+
+This affect the ability to nest ``IPython.embed()`` which may
 require you to install alternate IO libraries  like ``curio`` and ``trio``