Merge pull request #11265 from Carreau/async-repl-aug-2018

Prototype async REPL using IPython, take III

IPython/core/async_helpers.py

@@ -0,0 +1,157 b''
+"""
+Async helper function that are invalid syntax on Python 3.5 and below.
+
+This code is best effort, and may have edge cases not behaving as expected. In
+particular it contain a number of heuristics to detect whether code is
+effectively async and need to run in an event loop or not.
+
+Some constructs (like top-level `return`, or `yield`) are taken care of
+explicitly to actually raise a SyntaxError and stay as close as possible to
+Python semantics.
+"""
+
+
+import ast
+import sys
+from textwrap import dedent, indent
+
+
+class _AsyncIORunner:
+
+    def __call__(self, coro):
+        """
+        Handler for asyncio autoawait
+        """
+        import asyncio
+
+        return asyncio.get_event_loop().run_until_complete(coro)
+
+    def __str__(self):
+        return 'asyncio'
+
+_asyncio_runner = _AsyncIORunner()
+
+
+def _curio_runner(coroutine):
+    """
+    handler for curio autoawait
+    """
+    import curio
+
+    return curio.run(coroutine)
+
+
+def _trio_runner(async_fn):
+    import trio
+
+    async def loc(coro):
+        """
+        We need the dummy no-op async def to protect from
+        trio's internal. See https://github.com/python-trio/trio/issues/89
+        """
+        return await coro
+
+    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(
+            "{coro_name!r} needs a real async loop".format(coro_name=coro.__name__)
+        )
+
+
+def _asyncify(code: str) -> str:
+    """wrap code in async def definition.
+
+    And setup a bit of context to run it later.
+    """
+    res = dedent(
+        """
+    async def __wrapper__():
+        try:
+    {usercode}
+        finally:
+            locals()
+    """
+    ).format(usercode=indent(code, " " * 8))
+    return res
+
+
+class _AsyncSyntaxErrorVisitor(ast.NodeVisitor):
+    """
+    Find syntax errors that would be an error in an async repl, but because
+    the implementation involves wrapping the repl in an async function, it
+    is erroneously allowed (e.g. yield or return at the top level)
+    """
+
+    def generic_visit(self, node):
+        func_types = (ast.FunctionDef, ast.AsyncFunctionDef)
+        invalid_types = (ast.Return, ast.Yield, ast.YieldFrom)
+
+        if isinstance(node, func_types):
+            return  # Don't recurse into functions
+        elif isinstance(node, invalid_types):
+            raise SyntaxError()
+        else:
+            super().generic_visit(node)
+
+
+def _async_parse_cell(cell: str) -> ast.AST:
+    """
+    This is a compatibility shim for pre-3.7 when async outside of a function
+    is a syntax error at the parse stage.
+
+    It will return an abstract syntax tree parsed as if async and await outside
+    of a function were not a syntax error.
+    """
+    if sys.version_info < (3, 7):
+        # Prior to 3.7 you need to asyncify before parse
+        wrapped_parse_tree = ast.parse(_asyncify(cell))
+        return wrapped_parse_tree.body[0].body[0]
+    else:
+        return ast.parse(cell)
+
+
+def _should_be_async(cell: str) -> bool:
+    """Detect if a block of code need to be wrapped in an `async def`
+
+    Attempt to parse the block of code, it it compile we're fine.
+    Otherwise we  wrap if and try to compile.
+
+    If it works, assume it should be async. Otherwise Return False.
+
+    Not handled yet: If the block of code has a return statement as  the top
+    level, it will be seen as async. This is a know limitation.
+    """
+
+    try:
+        # we can't limit ourself to ast.parse, as it __accepts__ to parse on
+        # 3.7+, but just does not _compile_
+        compile(cell, "<>", "exec")
+        return False
+    except SyntaxError:
+        try:
+            parse_tree = _async_parse_cell(cell)
+
+            # Raise a SyntaxError if there are top-level return or yields
+            v = _AsyncSyntaxErrorVisitor()
+            v.visit(parse_tree)
+
+        except SyntaxError:
+            return False
+        return True
+    return False

IPython/core/tests/test_async_helpers.py

@@ -0,0 +1,277 b''
+"""
+Test for async helpers. 
+
+Should only trigger on python 3.5+ or will have syntax errors.
+"""
+
+import sys
+from itertools import chain, repeat
+import nose.tools as nt
+from textwrap import dedent, indent
+from unittest import TestCase
+from IPython.testing.decorators import skip_without
+
+ip = get_ipython()
+iprc = lambda x: ip.run_cell(dedent(x)).raise_error()
+iprc_nr = lambda x: ip.run_cell(dedent(x))
+
+if sys.version_info > (3, 5):
+    from IPython.core.async_helpers import _should_be_async
+
+    class AsyncTest(TestCase):
+        def test_should_be_async(self):
+            nt.assert_false(_should_be_async("False"))
+            nt.assert_true(_should_be_async("await bar()"))
+            nt.assert_true(_should_be_async("x = await bar()"))
+            nt.assert_false(
+                _should_be_async(
+                    dedent(
+                        """
+                async def awaitable():
+                    pass
+            """
+                    )
+                )
+            )
+
+        def _get_top_level_cases(self):
+            # These are test cases that should be valid in a function
+            # but invalid outside of a function.
+            test_cases = []
+            test_cases.append(('basic', "{val}"))
+
+            # Note, in all conditional cases, I use True instead of
+            # False so that the peephole optimizer won't optimize away
+            # the return, so CPython will see this as a syntax error:
+            #
+            # while True:
+            #    break
+            #    return
+            #
+            # But not this:
+            #
+            # while False:
+            #    return
+            #
+            # See https://bugs.python.org/issue1875
+
+            test_cases.append(('if', dedent("""
+            if True:
+                {val}
+            """)))
+
+            test_cases.append(('while', dedent("""
+            while True:
+                {val}
+                break
+            """)))
+
+            test_cases.append(('try', dedent("""
+            try:
+                {val}
+            except:
+                pass
+            """)))
+
+            test_cases.append(('except', dedent("""
+            try:
+                pass
+            except:
+                {val}
+            """)))
+
+            test_cases.append(('finally', dedent("""
+            try:
+                pass
+            except:
+                pass
+            finally:
+                {val}
+            """)))
+
+            test_cases.append(('for', dedent("""
+            for _ in range(4):
+                {val}
+            """)))
+
+
+            test_cases.append(('nested', dedent("""
+            if True:
+                while True:
+                    {val}
+                    break
+            """)))
+
+            test_cases.append(('deep-nested', dedent("""
+            if True:
+                while True:
+                    break
+                    for x in range(3):
+                        if True:
+                            while True:
+                                for x in range(3):
+                                    {val}
+            """)))
+
+            return test_cases
+
+        def _get_ry_syntax_errors(self):
+            # This is a mix of tests that should be a syntax error if
+            # return or yield whether or not they are in a function
+
+            test_cases = []
+
+            test_cases.append(('class', dedent("""
+            class V:
+                {val}
+            """)))
+
+            test_cases.append(('nested-class', dedent("""
+            class V:
+                class C:
+                    {val}
+            """)))
+
+            return test_cases
+
+
+        def test_top_level_return_error(self):
+            tl_err_test_cases = self._get_top_level_cases()
+            tl_err_test_cases.extend(self._get_ry_syntax_errors())
+
+            vals = ('return', 'yield', 'yield from (_ for _ in range(3))')
+
+            for test_name, test_case in tl_err_test_cases:
+                # This example should work if 'pass' is used as the value
+                with self.subTest((test_name, 'pass')):
+                    iprc(test_case.format(val='pass'))
+
+                # It should fail with all the values
+                for val in vals:
+                    with self.subTest((test_name, val)):
+                        msg = "Syntax error not raised for %s, %s" % (test_name, val)
+                        with self.assertRaises(SyntaxError, msg=msg):
+                            iprc(test_case.format(val=val))
+
+        def test_in_func_no_error(self):
+            # Test that the implementation of top-level return/yield
+            # detection isn't *too* aggressive, and works inside a function
+            func_contexts = []
+
+            func_contexts.append(('func', False, dedent("""
+            def f():""")))
+
+            func_contexts.append(('method', False, dedent("""
+            class MyClass:
+                def __init__(self):
+            """)))
+
+            func_contexts.append(('async-func', True,  dedent("""
+            async def f():""")))
+
+            func_contexts.append(('async-method', True,  dedent("""
+            class MyClass:
+                async def f(self):""")))
+
+            func_contexts.append(('closure', False, dedent("""
+            def f():
+                def g():
+            """)))
+
+            def nest_case(context, case):
+                # Detect indentation
+                lines = context.strip().splitlines()
+                prefix_len = 0
+                for c in lines[-1]:
+                    if c != ' ':
+                        break
+                    prefix_len += 1
+
+                indented_case = indent(case, ' ' * (prefix_len + 4))
+                return context + '\n' + indented_case
+
+            # Gather and run the tests
+
+            # yield is allowed in async functions, starting in Python 3.6,
+            # and yield from is not allowed in any version
+            vals = ('return', 'yield', 'yield from (_ for _ in range(3))')
+            async_safe = (True,
+                          sys.version_info >= (3, 6),
+                          False)
+            vals = tuple(zip(vals, async_safe))
+
+            success_tests = zip(self._get_top_level_cases(), repeat(False))
+            failure_tests = zip(self._get_ry_syntax_errors(), repeat(True))
+
+            tests = chain(success_tests, failure_tests)
+
+            for context_name, async_func, context in func_contexts:
+                for (test_name, test_case), should_fail in tests:
+                    nested_case = nest_case(context, test_case)
+
+                    for val, async_safe in vals:
+                        val_should_fail = (should_fail or
+                                           (async_func and not async_safe))
+
+                        test_id = (context_name, test_name, val)
+                        cell = nested_case.format(val=val)
+
+                        with self.subTest(test_id):
+                            if val_should_fail:
+                                msg = ("SyntaxError not raised for %s" %
+                                       str(test_id))
+                                with self.assertRaises(SyntaxError, msg=msg):
+                                    iprc(cell)
+
+                                    print(cell)
+                            else:
+                                iprc(cell)
+
+
+        def test_execute(self):
+            iprc("""
+            import asyncio
+            await asyncio.sleep(0.001)
+            """
+            )
+
+        def test_autoawait(self):
+            iprc("%autoawait False")
+            iprc("%autoawait True")
+            iprc("""
+            from asyncio import sleep
+            await sleep(0.1)
+            """
+            )
+
+        @skip_without('curio')
+        def test_autoawait_curio(self):
+            iprc("%autoawait curio")
+
+        @skip_without('trio')
+        def test_autoawait_trio(self):
+            iprc("%autoawait trio")
+
+        @skip_without('trio')
+        def test_autoawait_trio_wrong_sleep(self):
+            iprc("%autoawait trio")
+            res = iprc_nr("""
+            import asyncio
+            await asyncio.sleep(0)
+            """)
+            with nt.assert_raises(TypeError):
+                res.raise_error()
+
+        @skip_without('trio')
+        def test_autoawait_asyncio_wrong_sleep(self):
+            iprc("%autoawait asyncio")
+            res = iprc_nr("""
+            import trio
+            await trio.sleep(0)
+            """)
+            with nt.assert_raises(RuntimeError):
+                res.raise_error()
+
+
+        def tearDown(self):
+            ip.loop_runner = "asyncio"

docs/source/interactive/autoawait.rst

@@ -0,0 +1,222 b''
+.. _autoawait:
+
+Asynchronous in REPL: Autoawait
+===============================
+
+.. note::
+
+   This feature is experimental and behavior can change betwen python and
+   IPython version without prior deprecation.
+
+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.
+
+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 allow Futures and
+Coroutines in the REPL to be ``await`` ed. This will happen if an :ref:`await
+<await>` (or any other async constructs like async-with, async-for) 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
+Python REPL::
+
+    Python 3.6.0 
+    [GCC 4.2.1]
+    Type "help", "copyright", "credits" or "license" for more information.
+    >>> import aiohttp
+    >>> result = aiohttp.get('https://api.github.com')
+    >>> response = await result
+      File "<stdin>", line 1
+        response = await result
+                              ^
+    SyntaxError: invalid syntax
+
+Should behave as expected in the IPython REPL::
+
+    Python 3.6.0
+    Type 'copyright', 'credits' or 'license' for more information
+    IPython 7.0.0 -- An enhanced Interactive Python. Type '?' for help.
+
+    In [1]: import aiohttp
+       ...: result = aiohttp.get('https://api.github.com')
+
+    In [2]: response = await result
+    <pause for a few 100s ms>
+
+    In [3]: await response.json()
+    Out[3]:
+    {'authorizations_url': 'https://api.github.com/authorizations',
+     'code_search_url': 'https://api.github.com/search/code?q={query}...',
+    ...
+    }
+
+
+You can use the ``c.InteractiveShell.autoawait`` configuration option and set it
+to :any:`False` to deactivate automatic wrapping of asynchronous code. You can also
+use the :magic:`%autoawait` magic to toggle the behavior at runtime::
+
+    In [1]: %autoawait False
+
+    In [2]: %autoawait
+    IPython autoawait is `Off`, and set to use `asyncio`
+
+
+
+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.
+
+You can switch current integration by using the
+``c.InteractiveShell.loop_runner`` option or the ``autoawait <name
+integration>`` magic.
+
+For example::
+
+    In [1]: %autoawait trio
+
+    In [2]: import trio
+
+    In [3]: async def child(i):
+       ...:     print("   child %s goes to sleep"%i)
+       ...:     await trio.sleep(2)
+       ...:     print("   child %s wakes up"%i)
+
+    In [4]: print('parent start')
+       ...: async with trio.open_nursery() as n:
+       ...:     for i in range(5):
+       ...:         n.spawn(child, i)
+       ...: print('parent end')
+    parent start
+       child 2 goes to sleep
+       child 0 goes to sleep
+       child 3 goes to sleep
+       child 1 goes to sleep
+       child 4 goes to sleep
+       <about 2 seconds pause>
+       child 2 wakes up
+       child 1 wakes up
+       child 0 wakes up
+       child 3 wakes up
+       child 4 wakes up
+    parent end
+
+
+In the above example, ``async with`` at top level scope is a syntax error in
+Python.
+
+Using this mode can have unexpected consequences if used in interaction with
+other features of IPython and various registered extensions. In particular if you
+are a direct or indirect user of the AST transformers, these may not apply to
+your code.
+
+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]``.
+
+
+Effects on IPython.embed()
+==========================
+
+IPython core being asynchronous, the use of ``IPython.embed()`` will now require
+a loop to run. By default IPython will use a fake coroutine runner which should
+allow ``IPython.embed()`` to be nested. Though this will prevent usage of the
+``autoawait`` feature when using IPython embed. 
+
+You can set explicitly a coroutine runner for ``embed()`` if you desire to run
+asynchronous code, the exact behavior is though undefined.
+
+Effects on Magics
+=================
+
+A couple of magics (``%%timeit``, ``%timeit``, ``%%time``, ``%%prun``) have not
+yet been updated to work with asynchronous code and will raise syntax errors
+when trying to use top-level ``await``. We welcome any contribution to help fix
+those, and extra cases we haven't caught yet. We hope for better support in Cor
+Python for top-level Async code.
+
+Internals
+=========
+
+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 and heuristic 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 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)
+        #
+        # here is user code
+        #
+        return last_user_statement
+    codeobj = modify(inner_async.__code__)
+    coroutine = eval(codeobj, user_ns)
+    display(loop_runner(coroutine))
+
+
+
+The first thing you'll notice is that unlike classical ``exec``, there is only
+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
+``function``, and ``loop_runner`` can be arbitrary complex. So there is a
+significant overhead to this kind of code.
+
+By default the generated coroutine function will be consumed by Asyncio's
+``loop_runner = asyncio.get_evenloop().run_until_complete()`` method if
+``async`` mode is deemed necessary, otherwise the coroutine will just be
+exhausted in a simple runner. It is though possible to change the default
+runner.
+
+A loop runner is a *synchronous*  function responsible from running a coroutine
+object.
+
+The runner is responsible from ensuring that ``coroutine`` run to completion,
+and should return the result of executing the coroutine. Let's write a
+runner for ``trio`` that print a message when used as an exercise, ``trio`` is
+special as it usually prefer to run a function object and make a coroutine by
+itself, we can get around this limitation by wrapping it in an async-def without
+parameters and passing this value to ``trio``::
+
+
+    In [1]: import trio
+       ...: from types import CoroutineType
+       ...:
+       ...: def trio_runner(coro:CoroutineType):
+       ...:     print('running asynchronous code')
+       ...:     async def corowrap(coro):
+       ...:         return await coro
+       ...:     return trio.run(corowrap, coro)
+
+We can set it up by passing it to ``%autoawait``::
+
+    In [2]: %autoawait trio_runner
+
+    In [3]: async def async_hello(name):
+       ...:     await trio.sleep(1)
+       ...:     print(f'Hello {name} world !')
+       ...:     await trio.sleep(1)
+
+    In [4]: await async_hello('async')
+    running asynchronous code
+    Hello async world !
+
+
+Asynchronous programming in python (and in particular in the REPL) is still a
+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.
+
+We invite you to thoroughly test this feature and report any unexpected behavior
+as well as propose any improvement.

docs/source/whatsnew/pr/await-repl.rst

@@ -0,0 +1,99 b''
+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 :ref:`autoawait` section of our docs, see
+:ghpull:`11265` or try the following code::
+
+    Python 3.6.0
+    Type 'copyright', 'credits' or 'license' for more information
+    IPython 7.0.0 -- An enhanced Interactive Python. Type '?' for help.
+
+    In [1]: import aiohttp
+       ...: result = aiohttp.get('https://api.github.com')
+
+    In [2]: response = await result
+    <pause for a few 100s ms>
+
+    In [3]: await response.json()
+    Out[3]:
+    {'authorizations_url': 'https://api.github.com/authorizations',
+     'code_search_url': 'https://api.github.com/search/code?q={query}{&page,per_page,sort,order}',
+    ...
+    }
+
+.. note::
+
+   Async integration is experimental code, behavior may change or be removed
+   between Python and IPython versions without warnings.
+
+Integration is by default with `asyncio`, but other libraries can be configured, 
+like ``curio`` or ``trio``, to improve concurrency in the REPL::
+
+    In [1]: %autoawait trio
+
+    In [2]: import trio
+
+    In [3]: async def child(i):
+       ...:     print("   child %s goes to sleep"%i)
+       ...:     await trio.sleep(2)
+       ...:     print("   child %s wakes up"%i)
+
+    In [4]: print('parent start')
+       ...: async with trio.open_nursery() as n:
+       ...:     for i in range(3):
+       ...:         n.spawn(child, i)
+       ...: print('parent end')
+    parent start
+       child 2 goes to sleep
+       child 0 goes to sleep
+       child 1 goes to sleep
+       <about 2 seconds pause>
+       child 2 wakes up
+       child 1 wakes up
+       child 0 wakes up
+    parent end
+
+See :ref:`autoawait` for more information.
+
+
+Asynchronous code in a Notebook interface or any other frontend using the
+Jupyter Protocol will need further updates of the IPykernel package.
+
+Non-Asynchronous code 
+---------------------
+
+As the internal API of IPython are now asynchronous, IPython need to run under
+an even loop. In order to allow many workflow, (like using the ``%run`` magic,
+or copy_pasting code that explicitly starts/stop event loop), when top-level code
+is detected as not being asynchronous, IPython code is advanced via a
+pseudo-synchronous runner, and will not may not advance pending tasks.
+
+Change to Nested Embed
+----------------------
+
+The introduction of the ability to run async code had some effect on the
+``IPython.embed()`` API. By default embed will not allow you to run asynchronous
+code unless a event loop is specified.
+
+Effects on Magics
+-----------------
+
+Some magics will not work with Async, and will need updates. Contribution
+welcome.
+
+Expected Future changes
+-----------------------
+
+We expect more internal but public IPython function to become ``async``, and
+will likely end up having a persisting event loop while IPython is running.
+
+Thanks
+------
+
+This took more than a year in the making, and the code was rebased a number of
+time leading to commit authorship that may have been lost in the final
+Pull-Request. Huge thanks to many people for contribution, discussion, code,
+documentation, use-case: dalejung, danielballan, ellisonbg, fperez, gnestor,
+minrk, njsmith, pganssle, tacaswell, takluyver , vidartf ... And many other.

tools/fixup_whats_new_pr.py

@@ -0,0 +1,43 b''
+"""
+This tool is used during CI testing to make sure sphinx raise no error.
+
+During development, we like to have whatsnew/pr/*.rst documents to track
+individual new features. Unfortunately they other either:
+  - have no title (sphinx complains)
+  - are not included in any toctree (sphinx complain)
+
+This fix-them up by "inventing" a title, before building the docs. At release
+time, these title and files will anyway be rewritten into the actual release
+notes.
+"""
+
+import glob
+
+
+def main():
+    folder = 'docs/source/whatsnew/pr/'
+    assert folder.endswith('/')
+    files = glob.glob(folder+'*.rst')
+    print(files)
+
+    for filename in files:
+        print('Adding pseudo-title to:', filename)
+        title = filename[:-4].split('/')[-1].replace('-', ' ').capitalize()
+
+        with open(filename) as f:
+            data = f.read()
+        if data and data.splitlines()[1].startswith('='):
+            continue
+
+        with open(filename, 'w') as f:
+            f.write(title+'\n')
+            f.write('='* len(title)+'\n\n')
+            f.write(data)
+
+if __name__ == '__main__':
+    main()
+
+
+
+
+

.travis.yml

@@ -5,7 +5,6 b' python:'
     - "3.7-dev"
     - 3.6
     - 3.5
-    - 3.4
 sudo: false
 env:
   global:
@@ -17,6 +16,7 b' install:'
     - pip install pip --upgrade
     - pip install setuptools --upgrade
     - pip install -e file://$PWD#egg=ipython[test] --upgrade
+    - pip install trio curio
     - pip install codecov check-manifest --upgrade
     - sudo apt-get install graphviz
 script:
@@ -26,6 +26,7 b' script:'
     - |
       if [[ "$TRAVIS_PYTHON_VERSION" == "3.6" ]]; then
         pip install -r docs/requirements.txt
+        python tools/fixup_whats_new_pr.py
         make -C docs/ html SPHINXOPTS="-W"
       fi
 after_success:

IPython/__init__.py

@@ -27,12 +27,12 b' import sys'
 #-----------------------------------------------------------------------------
 
 # Don't forget to also update setup.py when this changes!
-if sys.version_info < (3,4):
+if sys.version_info < (3, 5):
     raise ImportError(
 """
-IPython 7.0+ supports Python 3.4 and above.
+IPython 7.0+ supports Python 3.5 and above.
 When using Python 2.7, please install IPython 5.x LTS Long Term Support version.
-Python 3.3 was supported up to IPython 6.x.
+Python 3.3 and 3.4 were supported up to IPython 6.x.
 
 See IPython `README.rst` file for more information:
 

IPython/core/interactiveshell.py

@@ -13,6 +13,7 b''
 
 import abc
 import ast
+import asyncio
 import atexit
 import builtins as builtin_mod
 import functools
@@ -30,6 +31,7 b' from io import open as io_open'
 from pickleshare import PickleShareDB
 
 from traitlets.config.configurable import SingletonConfigurable
+from traitlets.utils.importstring import import_item
 from IPython.core import oinspect
 from IPython.core import magic
 from IPython.core import page
@@ -73,7 +75,7 b' from IPython.utils.text import format_screen, LSString, SList, DollarFormatter'
 from IPython.utils.tempdir import TemporaryDirectory
 from traitlets import (
     Integer, Bool, CaselessStrEnum, Enum, List, Dict, Unicode, Instance, Type,
-    observe, default,
+    observe, default, validate, Any
 )
 from warnings import warn
 from logging import error
@@ -113,6 +115,104 b' else:'
     _single_targets_nodes = (ast.AugAssign, )
 
 #-----------------------------------------------------------------------------
+# Await Helpers
+#-----------------------------------------------------------------------------
+
+def removed_co_newlocals(function:types.FunctionType) -> types.FunctionType:
+    """Return a function that do not create a new local scope. 
+
+    Given a function, create a clone of this function where the co_newlocal flag
+    has been removed, making this function code actually run in the sourounding
+    scope. 
+
+    We need this in order to run asynchronous code in user level namespace.
+    """
+    from types import CodeType, FunctionType
+    CO_NEWLOCALS = 0x0002
+    code = function.__code__
+    new_code = CodeType(
+        code.co_argcount, 
+        code.co_kwonlyargcount,
+        code.co_nlocals, 
+        code.co_stacksize, 
+        code.co_flags & ~CO_NEWLOCALS,
+        code.co_code, 
+        code.co_consts,
+        code.co_names, 
+        code.co_varnames, 
+        code.co_filename, 
+        code.co_name, 
+        code.co_firstlineno, 
+        code.co_lnotab, 
+        code.co_freevars, 
+        code.co_cellvars
+    )
+    return FunctionType(new_code, globals(), function.__name__, function.__defaults__)
+
+
+# we still need to run things using the asyncio eventloop, but there is no
+# async integration
+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
+else :
+    _curio_runner = _trio_runner = None
+
+    def _should_be_async(cell:str)->bool:
+        return False
+
+
+def _ast_asyncify(cell:str, wrapper_name:str) -> ast.Module:
+    """
+    Parse a cell with top-level await and modify the AST to be able to run it later.
+
+    Parameter
+    ---------
+
+    cell: str
+        The code cell to asyncronify
+    wrapper_name: str
+        The name of the function to be used to wrap the passed `cell`. It is
+        advised to **not** use a python identifier in order to not pollute the
+        global namespace in which the function will be ran.
+
+    Return
+    ------
+
+    A module object AST containing **one** function named `wrapper_name`.
+
+    The given code is wrapped in a async-def function, parsed into an AST, and
+    the resulting function definition AST is modified to return the last
+    expression.
+
+    The last expression or await node is moved into a return statement at the
+    end of the function, and removed from its original location. If the last
+    node is not Expr or Await nothing is done.
+
+    The function `__code__` will need to be later modified  (by
+    ``removed_co_newlocals``) in a subsequent step to not create new `locals()`
+    meaning that the local and global scope are the same, ie as if the body of
+    the function was at module level.
+
+    Lastly a call to `locals()` is made just before the last expression of the
+    function, or just after the last assignment or statement to make sure the
+    global dict is updated as python function work with a local fast cache which
+    is updated only on `local()` calls.
+    """
+
+    from ast import Expr, Await, Return
+    tree = ast.parse(_asyncify(cell))
+
+    function_def = tree.body[0]
+    function_def.name = wrapper_name
+    try_block = function_def.body[0]
+    lastexpr = try_block.body[-1]
+    if isinstance(lastexpr, (Expr, Await)):
+        try_block.body[-1] = Return(lastexpr.value)
+    ast.fix_missing_locations(tree)
+    return tree
+#-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
@@ -257,6 +357,43 b' class InteractiveShell(SingletonConfigurable):'
         """
     ).tag(config=True)
 
+    autoawait = Bool(True, help=
+        """
+        Automatically run await statement in the top level repl.
+        """
+    ).tag(config=True)
+
+    loop_runner_map ={
+        '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",
+        allow_none=True,
+        help="""Select the loop runner that will be used to execute top-level asynchronous code"""
+    ).tag(config=True)
+
+    @default('loop_runner')
+    def _default_loop_runner(self):
+        return import_item("IPython.core.interactiveshell._asyncio_runner")
+
+    @validate('loop_runner')
+    def _import_runner(self, proposal):
+        if isinstance(proposal.value, str):
+            if proposal.value in self.loop_runner_map:
+                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')
+            return runner
+        if not callable(proposal.value):
+            raise ValueError('loop_runner must be callable')
+        return proposal.value
+
     automagic = Bool(True, help=
         """
         Enable magic commands to be called without the leading %.
@@ -1464,6 +1601,7 b' class InteractiveShell(SingletonConfigurable):'
         parent = None
         obj = None
 
+
         # Look for the given name by splitting it in parts.  If the head is
         # found, then we look for all the remaining parts as members, and only
         # declare success if we can find them all.
@@ -1999,7 +2137,6 b' class InteractiveShell(SingletonConfigurable):'
         self.set_hook('complete_command', cd_completer, str_key = '%cd')
         self.set_hook('complete_command', reset_completer, str_key = '%reset')
 
-
     @skip_doctest
     def complete(self, text, line=None, cursor_pos=None):
         """Return the completed text and a list of completions.
@@ -2083,6 +2220,8 b' class InteractiveShell(SingletonConfigurable):'
             m.ExtensionMagics, m.HistoryMagics, m.LoggingMagics,
             m.NamespaceMagics, m.OSMagics, m.PylabMagics, m.ScriptMagics,
         )
+        if sys.version_info >(3,5):
+            self.register_magics(m.AsyncMagics)
 
         # Register Magic Aliases
         mman = self.magics_manager
@@ -2682,15 +2821,59 b' class InteractiveShell(SingletonConfigurable):'
                 self.events.trigger('post_run_cell', result)
         return result
 
-    def _run_cell(self, raw_cell, store_history, silent, shell_futures):
-        """Internal method to run a complete IPython cell.
+    def _run_cell(self, raw_cell:str, store_history:bool, silent:bool, shell_futures:bool):
+        """Internal method to run a complete IPython cell."""
+        coro = self.run_cell_async(
+            raw_cell,
+            store_history=store_history,
+            silent=silent,
+            shell_futures=shell_futures,
+        )
+
+        # run_cell_async is async, but may not actually need and eventloop.
+        # when this is the case, we want to run it using the pseudo_sync_runner
+        # so that code can invoke eventloops (for example via the %run , and
+        # `%paste` magic.
+        try:
+            interactivity = coro.send(None)
+        except StopIteration as exc:
+            return exc.value
+
+        # if code was not async, sending `None` was actually executing the code.
+        if isinstance(interactivity, ExecutionResult):
+            return interactivity
+
+        if interactivity == 'async':
+            try:
+                return self.loop_runner(coro)
+            except Exception as e:
+                info = ExecutionInfo(raw_cell, store_history, silent, shell_futures)
+                result = ExecutionResult(info)
+                result.error_in_exec = e
+                self.showtraceback(running_compiled_code=True)
+                return result
+        return _pseudo_sync_runner(coro)
+
+    @asyncio.coroutine
+    def run_cell_async(self, raw_cell:str, store_history=False, silent=False, shell_futures=True) -> ExecutionResult:
+        """Run a complete IPython cell asynchronously.
 
         Parameters
         ----------
         raw_cell : str
+          The code (including IPython code such as %magic functions) to run.
         store_history : bool
+          If True, the raw and translated cell will be stored in IPython's
+          history. For user code calling back into IPython's machinery, this
+          should be set to False.
         silent : bool
+          If True, avoid side-effects, such as implicit displayhooks and
+          and logging.  silent=True forces store_history=False.
         shell_futures : bool
+          If True, the code will share future statements with the interactive
+          shell. It will both be affected by previous __future__ imports, and
+          any __future__ imports in the code will affect the shell. If False,
+          __future__ imports are not shared in either direction.
 
         Returns
         -------
@@ -2754,13 +2937,33 b' class InteractiveShell(SingletonConfigurable):'
         # compiler
         compiler = self.compile if shell_futures else CachingCompiler()
 
+        _run_async = False
+
         with self.builtin_trap:
             cell_name = self.compile.cache(cell, self.execution_count)
 
             with self.display_trap:
                 # Compile to bytecode
                 try:
-                    code_ast = compiler.ast_parse(cell, filename=cell_name)
+                    if self.autoawait and _should_be_async(cell):
+                        # the code AST below will not be user code: we wrap it
+                        # in an `async def`. This will likely make some AST
+                        # transformer below miss some transform opportunity and
+                        # introduce a small coupling to run_code (in which we
+                        # bake some assumptions of what _ast_asyncify returns.
+                        # they are ways around (like grafting part of the ast
+                        # later:
+                        #    - Here, return code_ast.body[0].body[1:-1], as well
+                        #    as last expression in  return statement which is
+                        #    the user code part.
+                        #    - Let it go through the AST transformers, and graft
+                        #    - it back after the AST transform
+                        # But that seem unreasonable, at least while we
+                        # do not need it.
+                        code_ast = _ast_asyncify(cell, 'async-def-wrapper')
+                        _run_async = True
+                    else:
+                        code_ast = compiler.ast_parse(cell, filename=cell_name)
                 except self.custom_exceptions as e:
                     etype, value, tb = sys.exc_info()
                     self.CustomTB(etype, value, tb)
@@ -2785,9 +2988,14 b' class InteractiveShell(SingletonConfigurable):'
                 self.displayhook.exec_result = result
 
                 # Execute the user code
-                interactivity = 'none' if silent else self.ast_node_interactivity
-                has_raised = self.run_ast_nodes(code_ast.body, cell_name,
-                   interactivity=interactivity, compiler=compiler, result=result)
+                interactivity = "none" if silent else self.ast_node_interactivity
+                if _run_async:
+                    interactivity = 'async'
+                # yield interactivity so let run_cell decide whether to use
+                # an async loop_runner
+                yield interactivity
+                has_raised = yield from self.run_ast_nodes(code_ast.body, cell_name,
+                       interactivity=interactivity, compiler=compiler, result=result)
                 
                 self.last_execution_succeeded = not has_raised
                 self.last_execution_result = result
@@ -2861,12 +3069,12 b' class InteractiveShell(SingletonConfigurable):'
             except Exception:
                 warn("AST transformer %r threw an error. It will be unregistered." % transformer)
                 self.ast_transformers.remove(transformer)
-        
+
         if self.ast_transformers:
             ast.fix_missing_locations(node)
         return node
-                
 
+    @asyncio.coroutine
     def run_ast_nodes(self, nodelist:ListType[AST], cell_name:str, interactivity='last_expr',
                         compiler=compile, result=None):
         """Run a sequence of AST nodes. The execution mode depends on the
@@ -2887,6 +3095,12 b' class InteractiveShell(SingletonConfigurable):'
           are not displayed) 'last_expr_or_assign' will run the last expression
           or the last assignment. Other values for this parameter will raise a
           ValueError.
+
+          Experimental value: 'async' Will try to run top level interactive
+          async/await code in default runner, this will not respect the
+          interactivty setting and will only run the last node if it is an
+          expression. 
+
         compiler : callable
           A function with the same interface as the built-in compile(), to turn
           the AST nodes into code objects. Default is the built-in compile().
@@ -2915,6 +3129,7 b' class InteractiveShell(SingletonConfigurable):'
                     nodelist.append(nnode)
             interactivity = 'last_expr'
 
+        _async = False
         if interactivity == 'last_expr':
             if isinstance(nodelist[-1], ast.Expr):
                 interactivity = "last"
@@ -2927,20 +3142,32 b' class InteractiveShell(SingletonConfigurable):'
             to_run_exec, to_run_interactive = nodelist[:-1], nodelist[-1:]
         elif interactivity == 'all':
             to_run_exec, to_run_interactive = [], nodelist
+        elif interactivity == 'async':
+            _async = True
         else:
             raise ValueError("Interactivity was %r" % interactivity)
         try:
-            for i, node in enumerate(to_run_exec):
-                mod = ast.Module([node])
-                code = compiler(mod, cell_name, "exec")
-                if self.run_code(code, result):
-                    return True
-
-            for i, node in enumerate(to_run_interactive):
-                mod = ast.Interactive([node])
-                code = compiler(mod, cell_name, "single")
-                if self.run_code(code, result):
+            if _async:
+                # If interactivity is async the semantics of run_code are
+                # completely different Skip usual machinery.
+                mod = ast.Module(nodelist)
+                async_wrapper_code = compiler(mod, 'cell_name', 'exec')
+                exec(async_wrapper_code, self.user_global_ns, self.user_ns)
+                async_code = removed_co_newlocals(self.user_ns.pop('async-def-wrapper')).__code__
+                if (yield from self.run_code(async_code, result, async_=True)):
                     return True
+            else:
+                for i, node in enumerate(to_run_exec):
+                    mod = ast.Module([node])
+                    code = compiler(mod, cell_name, "exec")
+                    if (yield from self.run_code(code, result)):
+                        return True
+
+                for i, node in enumerate(to_run_interactive):
+                    mod = ast.Interactive([node])
+                    code = compiler(mod, cell_name, "single")
+                    if (yield from self.run_code(code, result)):
+                        return True
 
             # Flush softspace
             if softspace(sys.stdout, 0):
@@ -2963,7 +3190,23 b' class InteractiveShell(SingletonConfigurable):'
 
         return False
 
-    def run_code(self, code_obj, result=None):
+    def _async_exec(self, code_obj: types.CodeType, user_ns: dict):
+        """
+        Evaluate an asynchronous code object using a code runner
+
+        Fake asynchronous execution of code_object in a namespace via a proxy namespace.
+
+        Returns coroutine object, which can be executed via async loop runner
+
+        WARNING: The semantics of `async_exec` are quite different from `exec`,
+        in particular you can only pass a single namespace. It also return a
+        handle to the value of the last things returned by code_object.
+        """
+
+        return eval(code_obj, user_ns)
+
+    @asyncio.coroutine
+    def run_code(self, code_obj, result=None, *, async_=False):
         """Execute a code object.
 
         When an exception occurs, self.showtraceback() is called to display a
@@ -2975,6 +3218,8 b' class InteractiveShell(SingletonConfigurable):'
           A compiled code object, to be executed
         result : ExecutionResult, optional
           An object to store exceptions that occur during execution.
+        async_ :  Bool (Experimental)
+          Attempt to run top-level asynchronous code in a default loop.
 
         Returns
         -------
@@ -2992,8 +3237,12 b' class InteractiveShell(SingletonConfigurable):'
         try:
             try:
                 self.hooks.pre_run_code_hook()
-                #rprint('Running code', repr(code_obj)) # dbg
-                exec(code_obj, self.user_global_ns, self.user_ns)
+                if async_:
+                    last_expr = (yield from self._async_exec(code_obj, self.user_ns))
+                    code = compile('last_expr', 'fake', "single")
+                    exec(code, {'last_expr': last_expr})
+                else:
+                    exec(code_obj, self.user_global_ns, self.user_ns)
             finally:
                 # Reset our crash handler in place
                 sys.excepthook = old_excepthook

IPython/core/magics/__init__.py

@@ -14,7 +14,7 b''
 
 from ..magic import Magics, magics_class
 from .auto import AutoMagics
-from .basic import BasicMagics
+from .basic import BasicMagics, AsyncMagics
 from .code import CodeMagics, MacroToEdit
 from .config import ConfigMagics
 from .display import DisplayMagics

IPython/core/magics/basic.py

@@ -2,19 +2,20 b''
 
 
 import argparse
-import textwrap
+from logging import error
 import io
-import sys
 from pprint import pformat
+import textwrap
+import sys
+from warnings import warn
 
+from traitlets.utils.importstring import import_item
 from IPython.core import magic_arguments, page
 from IPython.core.error import UsageError
 from IPython.core.magic import Magics, magics_class, line_magic, magic_escapes
 from IPython.utils.text import format_screen, dedent, indent
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils.ipstruct import Struct
-from warnings import warn
-from logging import error
 
 
 class MagicsDisplay(object):
@@ -378,6 +379,8 b' Currently the magic system has the following functions:""",'
         except:
             xmode_switch_err('user')
 
+
+
     @line_magic
     def pip(self, args=''):
         """
@@ -597,3 +600,72 b' Currently the magic system has the following functions:""",'
         nb = v4.new_notebook(cells=cells)
         with io.open(args.filename, 'w', encoding='utf-8') as f:
             write(nb, f, version=4)
+
+@magics_class
+class AsyncMagics(BasicMagics):
+
+    @line_magic
+    def autoawait(self, parameter_s):
+        """
+        Allow to change the status of the autoawait option.
+
+        This allow you to set a specific asynchronous code runner.
+
+        If no value is passed, print the currently used asynchronous integration
+        and whether it is activated.
+
+        It can take a number of value evaluated in the following order:
+
+        - False/false/off deactivate autoawait integration
+        - True/true/on activate autoawait integration using configured default
+          loop
+        - 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. 
+
+        If the object is a fully qualified object name, attempt to import it and
+        set it as the runner, and activate autoawait.
+        
+        
+        The exact behavior of autoawait is experimental and subject to change
+        across version of IPython and Python.
+        """
+
+        param = parameter_s.strip()
+        d = {True: "on", False: "off"}
+
+        if not param:
+            print("IPython autoawait is `{}`, and set to use `{}`".format(
+                d[self.shell.autoawait],
+                self.shell.loop_runner
+            ))
+            return None
+
+        if param.lower() in ('false', 'off'):
+            self.shell.autoawait = False
+            return None
+        if param.lower() in ('true', 'on'):
+            self.shell.autoawait = True
+            return None
+
+        if param in self.shell.loop_runner_map:
+            self.shell.loop_runner, self.shell.autoawait = self.shell.loop_runner_map[param]
+            return None
+
+        if param in self.shell.user_ns :
+            self.shell.loop_runner = self.shell.user_ns[param]
+            self.shell.autoawait = True
+            return None
+
+        runner = import_item(param)
+
+        self.shell.loop_runner = runner
+        self.shell.autoawait = True

IPython/lib/tests/test_pretty.py

@@ -413,7 +413,7 b' def test_pretty_environ():'
     # reindent to align with 'environ' prefix
     dict_indented = dict_repr.replace('\n', '\n' + (' ' * len('environ')))
     env_repr = pretty.pretty(os.environ)
-    nt.assert_equals(env_repr, 'environ' + dict_indented)
+    nt.assert_equal(env_repr, 'environ' + dict_indented)
 
 
 def test_function_pretty():

IPython/terminal/embed.py

@@ -366,6 +366,9 b' def embed(**kwargs):'
         config = load_default_config()
         config.InteractiveShellEmbed = config.TerminalInteractiveShell
         kwargs['config'] = config
+    using = kwargs.get('using', 'sync')
+    if using :
+        kwargs['config'].update({'TerminalInteractiveShell':{'loop_runner':using, 'colors':'NoColor', 'autoawait': using!='sync'}})
     #save ps1/ps2 if defined
     ps1 = None
     ps2 = None
@@ -383,7 +386,7 b' def embed(**kwargs):'
     shell = InteractiveShellEmbed.instance(_init_location_id='%s:%s' % (
         frame.f_code.co_filename, frame.f_lineno), **kwargs)
     shell(header=header, stack_depth=2, compile_flags=compile_flags,
-          _call_location_id='%s:%s' % (frame.f_code.co_filename, frame.f_lineno))
+        _call_location_id='%s:%s' % (frame.f_code.co_filename, frame.f_lineno))
     InteractiveShellEmbed.clear_instance()
     #restore previous instance
     if saved_shell_instance is not None:

IPython/terminal/tests/test_embed.py

@@ -72,6 +72,7 b' def test_nest_embed():'
 
     child = pexpect.spawn(sys.executable, ['-m', 'IPython', '--colors=nocolor'],
                           env=env)
+    child.timeout = 5
     child.expect(ipy_prompt)
     child.sendline("import IPython")
     child.expect(ipy_prompt)
@@ -86,7 +87,8 b' def test_nest_embed():'
     except pexpect.TIMEOUT as e:
         print(e)
         #child.interact()
-    child.sendline("embed1 = get_ipython()"); child.expect(ipy_prompt)
+    child.sendline("embed1 = get_ipython()")
+    child.expect(ipy_prompt)
     child.sendline("print('true' if embed1 is not ip0 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)
@@ -103,7 +105,8 b' def test_nest_embed():'
     except pexpect.TIMEOUT as e:
         print(e)
         #child.interact()
-    child.sendline("embed2 = get_ipython()"); child.expect(ipy_prompt)
+    child.sendline("embed2 = get_ipython()")
+    child.expect(ipy_prompt)
     child.sendline("print('true' if embed2 is not embed1 else 'false')")
     assert(child.expect(['true\r\n', 'false\r\n']) == 0)
     child.expect(ipy_prompt)

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/conf.py

@@ -143,7 +143,8 b" today_fmt = '%B %d, %Y'"
 
 # Exclude these glob-style patterns when looking for source files. They are
 # relative to the source/ directory.
-exclude_patterns = ['whatsnew/pr']
+exclude_patterns = ['whatsnew/pr/antigravity-feature.*', 
+                    'whatsnew/pr/incompat-switching-to-perl.*']
 
 
 # If true, '()' will be appended to :func: etc. cross-reference text.

docs/source/interactive/index.rst

@@ -21,6 +21,7 b' done some work in the classic Python REPL.'
    plotting
    reference
    shell
+   autoawait
    tips
    python-ipython-diff
    magics

docs/source/whatsnew/development.rst

@@ -11,6 +11,31 b' This document describes in-flight development work.'
     `docs/source/whatsnew/pr` folder
 
 
+Released .... ...., 2017
+
+
+Need to be updated:
+
+.. toctree::
+   :maxdepth: 2
+   :glob: 
+
+   pr/*
+
+IPython 6 feature a major improvement in the completion machinery which is now
+capable of completing non-executed code. It is also the first version of IPython
+to stop compatibility with Python 2, which is still supported on the bugfix only
+5.x branch. Read below to have a non-exhaustive list of new features.
+
+Make sure you have pip > 9.0 before upgrading. 
+You should be able to update by using:
+
+.. code::
+
+    pip install ipython --upgrade
+
+
+
 
 .. DO NOT EDIT THIS LINE BEFORE RELEASE. FEATURE INSERTION POINT.
 

docs/source/whatsnew/pr/deprecations.rst

@@ -1,3 +1,6 b''
+Deprecations
+============
+
 A couple of unused function and methods have been deprecated and will be removed
 in future versions:
 

setup.py

@@ -26,7 +26,7 b' import sys'
 #
 # This check is also made in IPython/__init__, don't forget to update both when
 # changing Python version requirements.
-if sys.version_info < (3, 4):
+if sys.version_info < (3, 5):
     pip_message = 'This may be due to an out of date pip. Make sure you have pip >= 9.0.1.'
     try:
         import pip
@@ -42,9 +42,9 b' if sys.version_info < (3, 4):'
 
 
     error = """
-IPython 7.0+ supports Python 3.4 and above.
+IPython 7.0+ supports Python 3.5 and above.
 When using Python 2.7, please install IPython 5.x LTS Long Term Support version.
-Python 3.3 was supported up to IPython 6.x.
+Python 3.3 and 3.4 were supported up to IPython 6.x.
 
 See IPython `README.rst` file for more information:
 
@@ -230,7 +230,7 b' for key, deps in extras_require.items():'
 extras_require['all'] = everything
 
 if 'setuptools' in sys.modules:
-    setuptools_extra_args['python_requires'] = '>=3.4'
+    setuptools_extra_args['python_requires'] = '>=3.5'
     setuptools_extra_args['zip_safe'] = False
     setuptools_extra_args['entry_points'] = {
         'console_scripts': find_entry_points(),