doc, remove appveyor 3.4

IPython/core/async_helpers.py

@@ -89,6 +89,7 b' def _should_be_async(cell: str) -> bool:'
     except SyntaxError:
         try:
             ast.parse(_asyncify(cell))
+            # TODO verify ast has not "top level" return or yield.
         except SyntaxError:
             return False
         return True

IPython/core/interactiveshell.py

@@ -154,7 +154,7 b' def removed_co_newlocals(function:types.FunctionType) -> types.FunctionType:'
 # async integration
 from .async_helpers import (_asyncio_runner,  _asyncify)
 
-if sys.version_info > (3,5):
+if sys.version_info > (3, 5):
     from .async_helpers import _curio_runner, _trio_runner, _should_be_async
 else :
     _curio_runner = _trio_runner = None

appveyor.yml

@@ -8,10 +8,6 b' environment:'
      PYTHON_VERSION: "3.6.x"
      PYTHON_ARCH: "32"
 
-   - PYTHON: "C:\\Python34-x64"
-     PYTHON_VERSION: "3.4.x"
-     PYTHON_ARCH: "64"
-
    - PYTHON: "C:\\Python36-x64"
      PYTHON_VERSION: "3.6.x"
      PYTHON_ARCH: "64"

docs/source/interactive/autoawait.rst

@@ -3,12 +3,17 b''
 Asynchronous in REPL: Autoawait
 ===============================
 
-Starting with IPython 6.0, and when user Python 3.6 and above, IPython offer the
-ability to run asynchronous code from the REPL. constructs which are
+Starting with IPython 7.0, and when user Python 3.6 and above, IPython offer the
+ability to run asynchronous code from the REPL. Constructs which are
 :exc:`SyntaxError` s in the Python REPL can be used seamlessly in IPython.
 
-When a supported libray is used, IPython will automatically `await` Futures
-and Coroutines in the REPL. This will happen if an :ref:`await <await>` (or `async`) is
+The example given here are for terminal IPython, running async code in a
+notebook interface or any other frontend using the Jupyter protocol will need to
+use a newer version of IPykernel. The details of how async code runs in
+IPykernel will differ between IPython, IPykernel and their versions.
+
+When a supported library is used, IPython will automatically `await` Futures
+and Coroutines in the REPL. This will happen if an :ref:`await <await>` is
 use at top level scope, or if any structure valid only in `async def
 <https://docs.python.org/3/reference/compound_stmts.html#async-def>`_ function
 context are present. For example, the following being a syntax error in the
@@ -29,7 +34,7 b' Should behave as expected in the IPython REPL::'
 
     Python 3.6.0
     Type 'copyright', 'credits' or 'license' for more information
-    IPython 6.0.0.dev -- An enhanced Interactive Python. Type '?' for help.
+    IPython 7.0.0 -- An enhanced Interactive Python. Type '?' for help.
 
     In [1]: import aiohttp
        ...: result = aiohttp.get('https://api.github.com')
@@ -58,7 +63,9 b' use the :magic:`%autoawait` magic to toggle the behavior at runtime::'
 
 By default IPython will assume integration with Python's provided
 :mod:`asyncio`, but integration with other libraries is provided. In particular
-we provide experimental integration with the ``curio`` and ``trio`` library.
+we provide experimental integration with the ``curio`` and ``trio`` library, the
+later one being necessary if you require the ability to do nested call of
+IPython's ``embed()`` functionality.
 
 You can switch current integration by using the
 ``c.InteractiveShell.loop_runner`` option or the ``autoawait <name
@@ -103,24 +110,25 b' other features of IPython and various registered extensions. In particular if yo'
 are a direct or indirect user of the AST transformers, these may not apply to
 your code.
 
-The default loop, or runner does not run in the background, so top level
-asynchronous code must finish for the REPL to allow you to enter more code. As
-with usual Python semantic, the awaitables are started only when awaited for the
-first time. That is to say, in first example, no network request is done between
-``In[1]`` and ``In[2]``.
+When Using command line IPython, the default loop (or runner) does not process
+in the background, so top level asynchronous code must finish for the REPL to
+allow you to enter more code. As with usual Python semantic, the awaitables are
+started only when awaited for the first time. That is to say, in first example,
+no network request is done between ``In[1]`` and ``In[2]``.
 
 
 Internals
 =========
 
-As running asynchronous code is not supported in interactive REPL as of Python
-3.6 we have to rely to a number of complex workaround to allow this to happen.
-It is interesting to understand how this works in order to understand potential
+As running asynchronous code is not supported in interactive REPL (as of Python
+3.7) we have to rely to a number of complex workaround to allow this to happen.
+It is interesting to understand how this works in order to comprehend potential
 bugs, or provide a custom runner.
 
 Among the many approaches that are at our disposition, we find only one that
-suited out need. Under the hood we :ct the code object from a async-def function
-and run it in global namesapace after modifying the ``__code__`` object.::
+suited out need. Under the hood we use the code object from a async-def function
+and run it in global namespace after modifying it to not create a new
+``locals()`` scope::
 
     async def inner_async():
         locals().update(**global_namespace)
@@ -135,7 +143,7 b' and run it in global namesapace after modifying the ``__code__`` object.::'
 
 
 The first thing you'll notice is that unlike classical ``exec``, there is only
-one name space. Second, user code runs in a function scope, and not a module
+one namespace. Second, user code runs in a function scope, and not a module
 scope.
 
 On top of the above there are significant modification to the AST of
@@ -181,5 +189,5 b' We can set it up by passing it to ``%autoawait``::'
 
 
 Asynchronous programming in python (and in particular in the REPL) is still a
-relatively young subject. Feel free to contribute improvements to this codebase
-and give us feedback.
+relatively young subject. We expect some code to not behave as you expect, so
+feel free to contribute improvements to this codebase and give us feedback.

docs/source/whatsnew/development.rst

@@ -35,6 +35,34 b' You should be able to update by using:'
     pip install ipython --upgrade
 
 
+Autowait: Asynchronous REPL
+===========================
+
+Staring with IPython 7.0 and on Python 3.6+, IPython can automatically await
+code at top level, you should not need to access an event loop or runner
+yourself. To know more read the `autoawait`_ section of our docs, or try the
+following code::
+
+   In [6]: from asyncio import sleep
+      ...: print('Going to sleep...')
+      ...: await sleep(3)
+      ...: print('Waking up')
+   Going to sleep...
+   Waking up
+
+Asynchronous code in a Notebook interface or any other frontend using the
+Jupyter Protocol will need further updates of the IPykernel package.
+
+
+Change to Nested Embed
+======================
+
+The introduction of the ability to run async code had ripple effect on the
+ability to use nested IPython. You may need to install the ``trio`` library
+(version 05 at the time of this writing) to
+have this feature working. 
+
+
 .. DO NOT EDIT THIS LINE BEFORE RELEASE. FEATURE INSERTION POINT.