Merge pull request #13702 from Carreau/mdocs

Misc documentation fixes.

IPython/core/magics/basic.py

@@ -1,659 +1,659 b''
 """Implementation of basic magic functions."""
 
 
 import argparse
 from logging import error
 import io
 import os
 from pprint import pformat
 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
 
 
 class MagicsDisplay(object):
     def __init__(self, magics_manager, ignore=None):
         self.ignore = ignore if ignore else []
         self.magics_manager = magics_manager
     
     def _lsmagic(self):
         """The main implementation of the %lsmagic"""
         mesc = magic_escapes['line']
         cesc = magic_escapes['cell']
         mman = self.magics_manager
         magics = mman.lsmagic()
         out = ['Available line magics:',
                mesc + ('  '+mesc).join(sorted([m for m,v in magics['line'].items() if (v not in self.ignore)])),
                '',
                'Available cell magics:',
                cesc + ('  '+cesc).join(sorted([m for m,v in magics['cell'].items() if (v not in self.ignore)])),
                '',
                mman.auto_status()]
         return '\n'.join(out)
 
     def _repr_pretty_(self, p, cycle):
         p.text(self._lsmagic())
     
     def __str__(self):
         return self._lsmagic()
     
     def _jsonable(self):
         """turn magics dict into jsonable dict of the same structure
 
         replaces object instances with their class names as strings
         """
         magic_dict = {}
         mman = self.magics_manager
         magics = mman.lsmagic()
         for key, subdict in magics.items():
             d = {}
             magic_dict[key] = d
             for name, obj in subdict.items():
                 try:
                     classname = obj.__self__.__class__.__name__
                 except AttributeError:
                     classname = 'Other'
                 
                 d[name] = classname
         return magic_dict
         
     def _repr_json_(self):
         return self._jsonable()
 
 
 @magics_class
 class BasicMagics(Magics):
     """Magics that provide central IPython functionality.
 
     These are various magics that don't fit into specific categories but that
     are all part of the base 'IPython experience'."""
 
     @skip_doctest
     @magic_arguments.magic_arguments()
     @magic_arguments.argument(
         '-l', '--line', action='store_true',
         help="""Create a line magic alias."""
     )
     @magic_arguments.argument(
         '-c', '--cell', action='store_true',
         help="""Create a cell magic alias."""
     )
     @magic_arguments.argument(
         'name',
         help="""Name of the magic to be created."""
     )
     @magic_arguments.argument(
         'target',
         help="""Name of the existing line or cell magic."""
     )
     @magic_arguments.argument(
         '-p', '--params', default=None,
         help="""Parameters passed to the magic function."""
     )
     @line_magic
     def alias_magic(self, line=''):
         """Create an alias for an existing line or cell magic.
 
         Examples
         --------
         ::
 
           In [1]: %alias_magic t timeit
           Created `%t` as an alias for `%timeit`.
           Created `%%t` as an alias for `%%timeit`.
 
           In [2]: %t -n1 pass
           1 loops, best of 3: 954 ns per loop
 
           In [3]: %%t -n1
              ...: pass
              ...:
           1 loops, best of 3: 954 ns per loop
 
           In [4]: %alias_magic --cell whereami pwd
           UsageError: Cell magic function `%%pwd` not found.
           In [5]: %alias_magic --line whereami pwd
           Created `%whereami` as an alias for `%pwd`.
 
           In [6]: %whereami
           Out[6]: u'/home/testuser'
 
           In [7]: %alias_magic h history "-p -l 30" --line
           Created `%h` as an alias for `%history -l 30`.
         """
 
         args = magic_arguments.parse_argstring(self.alias_magic, line)
         shell = self.shell
         mman = self.shell.magics_manager
         escs = ''.join(magic_escapes.values())
 
         target = args.target.lstrip(escs)
         name = args.name.lstrip(escs)
 
         params = args.params
         if (params and
                 ((params.startswith('"') and params.endswith('"'))
                 or (params.startswith("'") and params.endswith("'")))):
             params = params[1:-1]
 
         # Find the requested magics.
         m_line = shell.find_magic(target, 'line')
         m_cell = shell.find_magic(target, 'cell')
         if args.line and m_line is None:
             raise UsageError('Line magic function `%s%s` not found.' %
                              (magic_escapes['line'], target))
         if args.cell and m_cell is None:
             raise UsageError('Cell magic function `%s%s` not found.' %
                              (magic_escapes['cell'], target))
 
         # If --line and --cell are not specified, default to the ones
         # that are available.
         if not args.line and not args.cell:
             if not m_line and not m_cell:
                 raise UsageError(
                     'No line or cell magic with name `%s` found.' % target
                 )
             args.line = bool(m_line)
             args.cell = bool(m_cell)
 
         params_str = "" if params is None else " " + params
 
         if args.line:
             mman.register_alias(name, target, 'line', params)
             print('Created `%s%s` as an alias for `%s%s%s`.' % (
                 magic_escapes['line'], name,
                 magic_escapes['line'], target, params_str))
 
         if args.cell:
             mman.register_alias(name, target, 'cell', params)
             print('Created `%s%s` as an alias for `%s%s%s`.' % (
                 magic_escapes['cell'], name,
                 magic_escapes['cell'], target, params_str))
 
     @line_magic
     def lsmagic(self, parameter_s=''):
         """List currently available magic functions."""
         return MagicsDisplay(self.shell.magics_manager, ignore=[])
 
     def _magic_docs(self, brief=False, rest=False):
         """Return docstrings from magic functions."""
         mman = self.shell.magics_manager
         docs = mman.lsmagic_docs(brief, missing='No documentation')
 
         if rest:
             format_string = '**%s%s**::\n\n%s\n\n'
         else:
             format_string = '%s%s:\n%s\n'
 
         return ''.join(
             [format_string % (magic_escapes['line'], fname,
                               indent(dedent(fndoc)))
              for fname, fndoc in sorted(docs['line'].items())]
             +
             [format_string % (magic_escapes['cell'], fname,
                               indent(dedent(fndoc)))
              for fname, fndoc in sorted(docs['cell'].items())]
         )
 
     @line_magic
     def magic(self, parameter_s=''):
         """Print information about the magic function system.
 
         Supported formats: -latex, -brief, -rest
         """
 
         mode = ''
         try:
             mode = parameter_s.split()[0][1:]
         except IndexError:
             pass
 
         brief = (mode == 'brief')
         rest = (mode == 'rest')
         magic_docs = self._magic_docs(brief, rest)
 
         if mode == 'latex':
             print(self.format_latex(magic_docs))
             return
         else:
             magic_docs = format_screen(magic_docs)
 
         out = ["""
 IPython's 'magic' functions
 ===========================
 
 The magic function system provides a series of functions which allow you to
 control the behavior of IPython itself, plus a lot of system-type
 features. There are two kinds of magics, line-oriented and cell-oriented.
 
 Line magics are prefixed with the % character and work much like OS
 command-line calls: they get as an argument the rest of the line, where
 arguments are passed without parentheses or quotes.  For example, this will
 time the given statement::
 
         %timeit range(1000)
 
 Cell magics are prefixed with a double %%, and they are functions that get as
 an argument not only the rest of the line, but also the lines below it in a
 separate argument.  These magics are called with two arguments: the rest of the
 call line and the body of the cell, consisting of the lines below the first.
 For example::
 
         %%timeit x = numpy.random.randn((100, 100))
         numpy.linalg.svd(x)
 
 will time the execution of the numpy svd routine, running the assignment of x
 as part of the setup phase, which is not timed.
 
 In a line-oriented client (the terminal or Qt console IPython), starting a new
 input with %% will automatically enter cell mode, and IPython will continue
 reading input until a blank line is given.  In the notebook, simply type the
 whole cell as one entity, but keep in mind that the %% escape can only be at
 the very start of the cell.
 
 NOTE: If you have 'automagic' enabled (via the command line option or with the
 %automagic function), you don't need to type in the % explicitly for line
 magics; cell magics always require an explicit '%%' escape.  By default,
 IPython ships with automagic on, so you should only rarely need the % escape.
 
 Example: typing '%cd mydir' (without the quotes) changes your working directory
 to 'mydir', if it exists.
 
 For a list of the available magic functions, use %lsmagic. For a description
 of any of them, type %magic_name?, e.g. '%cd?'.
 
 Currently the magic system has the following functions:""",
        magic_docs,
        "Summary of magic functions (from %slsmagic):" % magic_escapes['line'],
        str(self.lsmagic()),
        ]
         page.page('\n'.join(out))
 
 
     @line_magic
     def page(self, parameter_s=''):
         """Pretty print the object and display it through a pager.
 
         %page [options] OBJECT
 
         If no object is given, use _ (last output).
 
         Options:
 
           -r: page str(object), don't pretty-print it."""
 
         # After a function contributed by Olivier Aubert, slightly modified.
 
         # Process options/args
         opts, args = self.parse_options(parameter_s, 'r')
         raw = 'r' in opts
 
         oname = args and args or '_'
         info = self.shell._ofind(oname)
         if info['found']:
             txt = (raw and str or pformat)( info['obj'] )
             page.page(txt)
         else:
             print('Object `%s` not found' % oname)
 
     @line_magic
     def pprint(self, parameter_s=''):
         """Toggle pretty printing on/off."""
         ptformatter = self.shell.display_formatter.formatters['text/plain']
         ptformatter.pprint = bool(1 - ptformatter.pprint)
         print('Pretty printing has been turned',
               ['OFF','ON'][ptformatter.pprint])
 
     @line_magic
     def colors(self, parameter_s=''):
         """Switch color scheme for prompts, info system and exception handlers.
 
         Currently implemented schemes: NoColor, Linux, LightBG.
 
         Color scheme names are not case-sensitive.
 
         Examples
         --------
         To get a plain black and white terminal::
 
           %colors nocolor
         """
         def color_switch_err(name):
             warn('Error changing %s color schemes.\n%s' %
                  (name, sys.exc_info()[1]), stacklevel=2)
 
 
         new_scheme = parameter_s.strip()
         if not new_scheme:
             raise UsageError(
                 "%colors: you must specify a color scheme. See '%colors?'")
         # local shortcut
         shell = self.shell
 
         # Set shell colour scheme
         try:
             shell.colors = new_scheme
             shell.refresh_style()
         except:
             color_switch_err('shell')
 
         # Set exception colors
         try:
             shell.InteractiveTB.set_colors(scheme = new_scheme)
             shell.SyntaxTB.set_colors(scheme = new_scheme)
         except:
             color_switch_err('exception')
 
         # Set info (for 'object?') colors
         if shell.color_info:
             try:
                 shell.inspector.set_active_scheme(new_scheme)
             except:
                 color_switch_err('object inspector')
         else:
             shell.inspector.set_active_scheme('NoColor')
 
     @line_magic
     def xmode(self, parameter_s=''):
         """Switch modes for the exception handlers.
 
         Valid modes: Plain, Context, Verbose, and Minimal.
 
         If called without arguments, acts as a toggle.
 
-        When in verbose mode the value --show (and --hide)
+        When in verbose mode the value `--show` (and `--hide`)
         will respectively show (or hide) frames with ``__tracebackhide__ =
         True`` value set.
         """
 
         def xmode_switch_err(name):
             warn('Error changing %s exception modes.\n%s' %
                  (name,sys.exc_info()[1]))
 
         shell = self.shell
         if parameter_s.strip() == "--show":
             shell.InteractiveTB.skip_hidden = False
             return
         if parameter_s.strip() == "--hide":
             shell.InteractiveTB.skip_hidden = True
             return
 
         new_mode = parameter_s.strip().capitalize()
         try:
             shell.InteractiveTB.set_mode(mode=new_mode)
             print('Exception reporting mode:',shell.InteractiveTB.mode)
         except:
             xmode_switch_err('user')
 
     @line_magic
     def quickref(self, arg):
         """ Show a quick reference sheet """
         from IPython.core.usage import quick_reference
         qr = quick_reference + self._magic_docs(brief=True)
         page.page(qr)
 
     @line_magic
     def doctest_mode(self, parameter_s=''):
         """Toggle doctest mode on and off.
 
         This mode is intended to make IPython behave as much as possible like a
         plain Python shell, from the perspective of how its prompts, exceptions
         and output look.  This makes it easy to copy and paste parts of a
         session into doctests.  It does so by:
 
         - Changing the prompts to the classic ``>>>`` ones.
         - Changing the exception reporting mode to 'Plain'.
         - Disabling pretty-printing of output.
 
         Note that IPython also supports the pasting of code snippets that have
         leading '>>>' and '...' prompts in them.  This means that you can paste
         doctests from files or docstrings (even if they have leading
         whitespace), and the code will execute correctly.  You can then use
         '%history -t' to see the translated history; this will give you the
         input after removal of all the leading prompts and whitespace, which
         can be pasted back into an editor.
 
         With these features, you can switch into this mode easily whenever you
         need to do testing and changes to doctests, without having to leave
         your existing IPython session.
         """
 
         # Shorthands
         shell = self.shell
         meta = shell.meta
         disp_formatter = self.shell.display_formatter
         ptformatter = disp_formatter.formatters['text/plain']
         # dstore is a data store kept in the instance metadata bag to track any
         # changes we make, so we can undo them later.
         dstore = meta.setdefault('doctest_mode',Struct())
         save_dstore = dstore.setdefault
 
         # save a few values we'll need to recover later
         mode = save_dstore('mode',False)
         save_dstore('rc_pprint',ptformatter.pprint)
         save_dstore('xmode',shell.InteractiveTB.mode)
         save_dstore('rc_separate_out',shell.separate_out)
         save_dstore('rc_separate_out2',shell.separate_out2)
         save_dstore('rc_separate_in',shell.separate_in)
         save_dstore('rc_active_types',disp_formatter.active_types)
 
         if not mode:
             # turn on
 
             # Prompt separators like plain python
             shell.separate_in = ''
             shell.separate_out = ''
             shell.separate_out2 = ''
 
 
             ptformatter.pprint = False
             disp_formatter.active_types = ['text/plain']
 
             shell.magic('xmode Plain')
         else:
             # turn off
             shell.separate_in = dstore.rc_separate_in
 
             shell.separate_out = dstore.rc_separate_out
             shell.separate_out2 = dstore.rc_separate_out2
 
             ptformatter.pprint = dstore.rc_pprint
             disp_formatter.active_types = dstore.rc_active_types
 
             shell.magic('xmode ' + dstore.xmode)
 
         # mode here is the state before we switch; switch_doctest_mode takes
         # the mode we're switching to.
         shell.switch_doctest_mode(not mode)
 
         # Store new mode and inform
         dstore.mode = bool(not mode)
         mode_label = ['OFF','ON'][dstore.mode]
         print('Doctest mode is:', mode_label)
 
     @line_magic
     def gui(self, parameter_s=''):
         """Enable or disable IPython GUI event loop integration.
 
         %gui [GUINAME]
 
         This magic replaces IPython's threaded shells that were activated
         using the (pylab/wthread/etc.) command line flags.  GUI toolkits
         can now be enabled at runtime and keyboard
         interrupts should work without any problems.  The following toolkits
         are supported:  wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::
 
             %gui wx      # enable wxPython event loop integration
             %gui qt4|qt  # enable PyQt4 event loop integration
             %gui qt5     # enable PyQt5 event loop integration
             %gui gtk     # enable PyGTK event loop integration
             %gui gtk3    # enable Gtk3 event loop integration
             %gui gtk4    # enable Gtk4 event loop integration
             %gui tk      # enable Tk event loop integration
             %gui osx     # enable Cocoa event loop integration
                          # (requires %matplotlib 1.1)
             %gui         # disable all event loop integration
 
         WARNING:  after any of these has been called you can simply create
         an application object, but DO NOT start the event loop yourself, as
         we have already handled that.
         """
         opts, arg = self.parse_options(parameter_s, '')
         if arg=='': arg = None
         try:
             return self.shell.enable_gui(arg)
         except Exception as e:
             # print simple error message, rather than traceback if we can't
             # hook up the GUI
             error(str(e))
 
     @skip_doctest
     @line_magic
     def precision(self, s=''):
         """Set floating point precision for pretty printing.
 
         Can set either integer precision or a format string.
 
         If numpy has been imported and precision is an int,
         numpy display precision will also be set, via ``numpy.set_printoptions``.
 
         If no argument is given, defaults will be restored.
 
         Examples
         --------
         ::
 
             In [1]: from math import pi
 
             In [2]: %precision 3
             Out[2]: u'%.3f'
 
             In [3]: pi
             Out[3]: 3.142
 
             In [4]: %precision %i
             Out[4]: u'%i'
 
             In [5]: pi
             Out[5]: 3
 
             In [6]: %precision %e
             Out[6]: u'%e'
 
             In [7]: pi**10
             Out[7]: 9.364805e+04
 
             In [8]: %precision
             Out[8]: u'%r'
 
             In [9]: pi**10
             Out[9]: 93648.047476082982
         """
         ptformatter = self.shell.display_formatter.formatters['text/plain']
         ptformatter.float_precision = s
         return ptformatter.float_format
 
     @magic_arguments.magic_arguments()
     @magic_arguments.argument(
         'filename', type=str,
         help='Notebook name or filename'
     )
     @line_magic
     def notebook(self, s):
         """Export and convert IPython notebooks.
 
         This function can export the current IPython history to a notebook file.
         For example, to export the history to "foo.ipynb" do "%notebook foo.ipynb".
         """
         args = magic_arguments.parse_argstring(self.notebook, s)
         outfname = os.path.expanduser(args.filename)
 
         from nbformat import write, v4
 
         cells = []
         hist = list(self.shell.history_manager.get_range())
         if(len(hist)<=1):
             raise ValueError('History is empty, cannot export')
         for session, execution_count, source in hist[:-1]:
             cells.append(v4.new_code_cell(
                 execution_count=execution_count,
                 source=source
             ))
         nb = v4.new_notebook(cells=cells)
         with io.open(outfname, "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/core/tests/test_debugger.py

@@ -1,567 +1,576 b''
 """Tests for debugging machinery.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import bdb
 import builtins
 import os
 import sys
 import platform
 
 from tempfile import NamedTemporaryFile
 from textwrap import dedent
 from unittest.mock import patch
 
 from IPython.core import debugger
 from IPython.testing import IPYTHON_TESTING_TIMEOUT_SCALE
 from IPython.testing.decorators import skip_win32
 import pytest
 
 #-----------------------------------------------------------------------------
 # Helper classes, from CPython's Pdb test suite
 #-----------------------------------------------------------------------------
 
 class _FakeInput(object):
     """
     A fake input stream for pdb's interactive debugger.  Whenever a
     line is read, print it (to simulate the user typing it), and then
     return it.  The set of lines to return is specified in the
     constructor; they should not have trailing newlines.
     """
     def __init__(self, lines):
         self.lines = iter(lines)
 
     def readline(self):
         line = next(self.lines)
         print(line)
         return line+'\n'
 
 class PdbTestInput(object):
     """Context manager that makes testing Pdb in doctests easier."""
 
     def __init__(self, input):
         self.input = input
 
     def __enter__(self):
         self.real_stdin = sys.stdin
         sys.stdin = _FakeInput(self.input)
 
     def __exit__(self, *exc):
         sys.stdin = self.real_stdin
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 def test_ipdb_magics():
     '''Test calling some IPython magics from ipdb.
 
     First, set up some test functions and classes which we can inspect.
 
     >>> class ExampleClass(object):
     ...    """Docstring for ExampleClass."""
     ...    def __init__(self):
     ...        """Docstring for ExampleClass.__init__"""
     ...        pass
     ...    def __str__(self):
     ...        return "ExampleClass()"
 
     >>> def example_function(x, y, z="hello"):
     ...     """Docstring for example_function."""
     ...     pass
 
     >>> old_trace = sys.gettrace()
 
     Create a function which triggers ipdb.
 
     >>> def trigger_ipdb():
     ...    a = ExampleClass()
     ...    debugger.Pdb().set_trace()
 
     >>> with PdbTestInput([
     ...    'pdef example_function',
     ...    'pdoc ExampleClass',
     ...    'up',
     ...    'down',
     ...    'list',
     ...    'pinfo a',
     ...    'll',
     ...    'continue',
     ... ]):
     ...     trigger_ipdb()
     --Return--
     None
     > <doctest ...>(3)trigger_ipdb()
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> pdef example_function
      example_function(x, y, z='hello')
      ipdb> pdoc ExampleClass
     Class docstring:
         Docstring for ExampleClass.
     Init docstring:
         Docstring for ExampleClass.__init__
     ipdb> up
     > <doctest ...>(11)<module>()
           7    'pinfo a',
           8    'll',
           9    'continue',
          10 ]):
     ---> 11     trigger_ipdb()
     <BLANKLINE>
     ipdb> down
     None
     > <doctest ...>(3)trigger_ipdb()
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> list
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> pinfo a
     Type:           ExampleClass
     String form:    ExampleClass()
     Namespace:      Local...
     Docstring:      Docstring for ExampleClass.
     Init docstring: Docstring for ExampleClass.__init__
     ipdb> ll
           1 def trigger_ipdb():
           2    a = ExampleClass()
     ----> 3    debugger.Pdb().set_trace()
     <BLANKLINE>
     ipdb> continue
     
     Restore previous trace function, e.g. for coverage.py    
     
     >>> sys.settrace(old_trace)
     '''
 
 def test_ipdb_magics2():
     '''Test ipdb with a very short function.
     
     >>> old_trace = sys.gettrace()
 
     >>> def bar():
     ...     pass
 
     Run ipdb.
 
     >>> with PdbTestInput([
     ...    'continue',
     ... ]):
     ...     debugger.Pdb().runcall(bar)
     > <doctest ...>(2)bar()
           1 def bar():
     ----> 2    pass
     <BLANKLINE>
     ipdb> continue
     
     Restore previous trace function, e.g. for coverage.py    
     
     >>> sys.settrace(old_trace)
     '''
 
 def can_quit():
     '''Test that quit work in ipydb
 
     >>> old_trace = sys.gettrace()
 
     >>> def bar():
     ...     pass
 
     >>> with PdbTestInput([
     ...    'quit',
     ... ]):
     ...     debugger.Pdb().runcall(bar)
     > <doctest ...>(2)bar()
             1 def bar():
     ----> 2    pass
     <BLANKLINE>
     ipdb> quit
 
     Restore previous trace function, e.g. for coverage.py
 
     >>> sys.settrace(old_trace)
     '''
 
 
 def can_exit():
     '''Test that quit work in ipydb
 
     >>> old_trace = sys.gettrace()
 
     >>> def bar():
     ...     pass
 
     >>> with PdbTestInput([
     ...    'exit',
     ... ]):
     ...     debugger.Pdb().runcall(bar)
     > <doctest ...>(2)bar()
             1 def bar():
     ----> 2    pass
     <BLANKLINE>
     ipdb> exit
 
     Restore previous trace function, e.g. for coverage.py
 
     >>> sys.settrace(old_trace)
     '''
 
 
 def test_interruptible_core_debugger():
     """The debugger can be interrupted.
 
     The presumption is there is some mechanism that causes a KeyboardInterrupt
     (this is implemented in ipykernel).  We want to ensure the
     KeyboardInterrupt cause debugging to cease.
     """
     def raising_input(msg="", called=[0]):
         called[0] += 1
         assert called[0] == 1, "input() should only be called once!"
         raise KeyboardInterrupt()
 
     tracer_orig = sys.gettrace()
     try:
         with patch.object(builtins, "input", raising_input):
             debugger.InterruptiblePdb().set_trace()
             # The way this test will fail is by set_trace() never exiting,
             # resulting in a timeout by the test runner. The alternative
             # implementation would involve a subprocess, but that adds issues
             # with interrupting subprocesses that are rather complex, so it's
             # simpler just to do it this way.
     finally:
         # restore the original trace function
         sys.settrace(tracer_orig)
 
 
 @skip_win32
 def test_xmode_skip():
     """that xmode skip frames
 
     Not as a doctest as pytest does not run doctests.
     """
     import pexpect
     env = os.environ.copy()
     env["IPY_TEST_SIMPLE_PROMPT"] = "1"
 
     child = pexpect.spawn(
         sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
     )
     child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
 
     child.expect("IPython")
     child.expect("\n")
     child.expect_exact("In [1]")
 
     block = dedent(
         """
     def f():
         __tracebackhide__ = True
         g()
 
     def g():
         raise ValueError
 
     f()
     """
     )
 
     for line in block.splitlines():
         child.sendline(line)
         child.expect_exact(line)
     child.expect_exact("skipping")
 
     block = dedent(
         """
     def f():
         __tracebackhide__ = True
         g()
 
     def g():
         from IPython.core.debugger import set_trace
         set_trace()
 
     f()
     """
     )
 
     for line in block.splitlines():
         child.sendline(line)
         child.expect_exact(line)
 
     child.expect("ipdb>")
     child.sendline("w")
     child.expect("hidden")
     child.expect("ipdb>")
     child.sendline("skip_hidden false")
     child.sendline("w")
     child.expect("__traceba")
     child.expect("ipdb>")
 
     child.close()
 
 
 skip_decorators_blocks = (
     """
     def helpers_helper():
         pass # should not stop here except breakpoint
     """,
     """
     def helper_1():
         helpers_helper() # should not stop here
     """,
     """
     def helper_2():
         pass # should not stop here
     """,
     """
     def pdb_skipped_decorator2(function):
         def wrapped_fn(*args, **kwargs):
             __debuggerskip__ = True
             helper_2()
             __debuggerskip__ = False
             result = function(*args, **kwargs)
             __debuggerskip__ = True
             helper_2()
             return result
         return wrapped_fn
     """,
     """
     def pdb_skipped_decorator(function):
         def wrapped_fn(*args, **kwargs):
             __debuggerskip__ = True
             helper_1()
             __debuggerskip__ = False
             result = function(*args, **kwargs)
             __debuggerskip__ = True
             helper_2()
             return result
         return wrapped_fn
     """,
     """
     @pdb_skipped_decorator
     @pdb_skipped_decorator2
     def bar(x, y):
         return x * y
     """,
     """import IPython.terminal.debugger as ipdb""",
     """
     def f():
         ipdb.set_trace()
         bar(3, 4)
     """,
     """
     f()
     """,
 )
 
 
 def _decorator_skip_setup():
     import pexpect
 
     env = os.environ.copy()
     env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+    env["PROMPT_TOOLKIT_NO_CPR"] = "1"
 
     child = pexpect.spawn(
         sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
     )
     child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
 
     child.expect("IPython")
     child.expect("\n")
 
     child.timeout = 5 * IPYTHON_TESTING_TIMEOUT_SCALE
+    child.str_last_chars = 500
 
     dedented_blocks = [dedent(b).strip() for b in skip_decorators_blocks]
     in_prompt_number = 1
     for cblock in dedented_blocks:
         child.expect_exact(f"In [{in_prompt_number}]:")
         in_prompt_number += 1
         for line in cblock.splitlines():
             child.sendline(line)
             child.expect_exact(line)
         child.sendline("")
     return child
 
 
[e-mail](reason="recently fail for unknown reason on CI")
 @skip_win32
 def test_decorator_skip():
     """test that decorator frames can be skipped."""
 
     child = _decorator_skip_setup()
 
+    child.expect_exact("ipython-input-8")
     child.expect_exact("3     bar(3, 4)")
     child.expect("ipdb>")
 
     child.expect("ipdb>")
     child.sendline("step")
     child.expect_exact("step")
+    child.expect_exact("--Call--")
+    child.expect_exact("ipython-input-6")
 
     child.expect_exact("1 @pdb_skipped_decorator")
 
     child.sendline("s")
     child.expect_exact("return x * y")
 
     child.close()
 
 
[e-mail](reason="recently fail for unknown reason on CI")
 @pytest.mark.skipif(platform.python_implementation() == "PyPy", reason="issues on PyPy")
 @skip_win32
 def test_decorator_skip_disabled():
     """test that decorator frame skipping can be disabled"""
 
     child = _decorator_skip_setup()
 
     child.expect_exact("3     bar(3, 4)")
 
     for input_, expected in [
         ("skip_predicates debuggerskip False", ""),
         ("skip_predicates", "debuggerskip : False"),
         ("step", "---> 2     def wrapped_fn"),
         ("step", "----> 3         __debuggerskip__"),
         ("step", "----> 4         helper_1()"),
         ("step", "---> 1 def helper_1():"),
         ("next", "----> 2     helpers_helper()"),
         ("next", "--Return--"),
         ("next", "----> 5         __debuggerskip__ = False"),
     ]:
         child.expect("ipdb>")
         child.sendline(input_)
         child.expect_exact(input_)
         child.expect_exact(expected)
 
     child.close()
 
 
 @pytest.mark.skipif(platform.python_implementation() == "PyPy", reason="issues on PyPy")
 @skip_win32
 def test_decorator_skip_with_breakpoint():
     """test that decorator frame skipping can be disabled"""
 
     import pexpect
 
     env = os.environ.copy()
     env["IPY_TEST_SIMPLE_PROMPT"] = "1"
+    env["PROMPT_TOOLKIT_NO_CPR"] = "1"
 
     child = pexpect.spawn(
         sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
     )
     child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
+    child.str_last_chars = 500
 
     child.expect("IPython")
     child.expect("\n")
 
     child.timeout = 5 * IPYTHON_TESTING_TIMEOUT_SCALE
 
     ### we need a filename, so we need to exec the full block with a filename
     with NamedTemporaryFile(suffix=".py", dir=".", delete=True) as tf:
 
         name = tf.name[:-3].split("/")[-1]
         tf.write("\n".join([dedent(x) for x in skip_decorators_blocks[:-1]]).encode())
         tf.flush()
         codeblock = f"from {name} import f"
 
         dedented_blocks = [
             codeblock,
             "f()",
         ]
 
         in_prompt_number = 1
         for cblock in dedented_blocks:
             child.expect_exact(f"In [{in_prompt_number}]:")
             in_prompt_number += 1
             for line in cblock.splitlines():
                 child.sendline(line)
                 child.expect_exact(line)
             child.sendline("")
 
         # as the filename does not exists, we'll rely on the filename prompt
         child.expect_exact("47     bar(3, 4)")
 
         for input_, expected in [
             (f"b {name}.py:3", ""),
             ("step", "1---> 3     pass # should not stop here except"),
             ("step", "---> 38 @pdb_skipped_decorator"),
             ("continue", ""),
         ]:
             child.expect("ipdb>")
             child.sendline(input_)
             child.expect_exact(input_)
             child.expect_exact(expected)
 
     child.close()
 
 
 @skip_win32
 def test_where_erase_value():
     """Test that `where` does not access f_locals and erase values."""
     import pexpect
 
     env = os.environ.copy()
     env["IPY_TEST_SIMPLE_PROMPT"] = "1"
 
     child = pexpect.spawn(
         sys.executable, ["-m", "IPython", "--colors=nocolor"], env=env
     )
     child.timeout = 15 * IPYTHON_TESTING_TIMEOUT_SCALE
 
     child.expect("IPython")
     child.expect("\n")
     child.expect_exact("In [1]")
 
     block = dedent(
         """
     def simple_f():
          myvar = 1
          print(myvar)
          1/0
          print(myvar)
     simple_f()    """
     )
 
     for line in block.splitlines():
         child.sendline(line)
         child.expect_exact(line)
     child.expect_exact("ZeroDivisionError")
     child.expect_exact("In [2]:")
 
     child.sendline("%debug")
 
     ##
     child.expect("ipdb>")
 
     child.sendline("myvar")
     child.expect("1")
 
     ##
     child.expect("ipdb>")
 
     child.sendline("myvar = 2")
 
     ##
     child.expect_exact("ipdb>")
 
     child.sendline("myvar")
 
     child.expect_exact("2")
 
     ##
     child.expect("ipdb>")
     child.sendline("where")
 
     ##
     child.expect("ipdb>")
     child.sendline("myvar")
 
     child.expect_exact("2")
     child.expect("ipdb>")
 
     child.close()

IPython/terminal/debugger.py

@@ -1,167 +1,178 b''
 import asyncio
 import os
 import sys
 
 from IPython.core.debugger import Pdb
 from IPython.core.completer import IPCompleter
 from .ptutils import IPythonPTCompleter
 from .shortcuts import create_ipython_shortcuts
 from . import embed
 
 from pathlib import Path
 from pygments.token import Token
 from prompt_toolkit.shortcuts.prompt import PromptSession
 from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.formatted_text import PygmentsTokens
 from prompt_toolkit.history import InMemoryHistory, FileHistory
 from concurrent.futures import ThreadPoolExecutor
 
 from prompt_toolkit import __version__ as ptk_version
 PTK3 = ptk_version.startswith('3.')
 
 
+# we want to avoid ptk as much as possible when using subprocesses
+# as it uses cursor positioning requests, deletes color ....
+_use_simple_prompt = "IPY_TEST_SIMPLE_PROMPT" in os.environ
+
+
 class TerminalPdb(Pdb):
     """Standalone IPython debugger."""
 
     def __init__(self, *args, pt_session_options=None, **kwargs):
         Pdb.__init__(self, *args, **kwargs)
         self._ptcomp = None
         self.pt_init(pt_session_options)
         self.thread_executor = ThreadPoolExecutor(1)
 
     def pt_init(self, pt_session_options=None):
         """Initialize the prompt session and the prompt loop
         and store them in self.pt_app and self.pt_loop.
 
         Additional keyword arguments for the PromptSession class
         can be specified in pt_session_options.
         """
         if pt_session_options is None:
             pt_session_options = {}
 
         def get_prompt_tokens():
             return [(Token.Prompt, self.prompt)]
 
         if self._ptcomp is None:
             compl = IPCompleter(
                 shell=self.shell, namespace={}, global_namespace={}, parent=self.shell
             )
             # add a completer for all the do_ methods
             methods_names = [m[3:] for m in dir(self) if m.startswith("do_")]
 
             def gen_comp(self, text):
                 return [m for m in methods_names if m.startswith(text)]
             import types
             newcomp = types.MethodType(gen_comp, compl)
             compl.custom_matchers.insert(0, newcomp)
             # end add completer.
 
             self._ptcomp = IPythonPTCompleter(compl)
 
         # setup history only when we start pdb
         if self.shell.debugger_history is None:
             if self.shell.debugger_history_file is not None:
 
                 p = Path(self.shell.debugger_history_file).expanduser()
                 if not p.exists():
                     p.touch()
                 self.debugger_history = FileHistory(os.path.expanduser(str(p)))
             else:
                 self.debugger_history = InMemoryHistory()
         else:
             self.debugger_history = self.shell.debugger_history
 
         options = dict(
             message=(lambda: PygmentsTokens(get_prompt_tokens())),
             editing_mode=getattr(EditingMode, self.shell.editing_mode.upper()),
             key_bindings=create_ipython_shortcuts(self.shell),
             history=self.debugger_history,
             completer=self._ptcomp,
             enable_history_search=True,
             mouse_support=self.shell.mouse_support,
             complete_style=self.shell.pt_complete_style,
             style=getattr(self.shell, "style", None),
             color_depth=self.shell.color_depth,
         )
 
         if not PTK3:
             options['inputhook'] = self.shell.inputhook
         options.update(pt_session_options)
-        self.pt_loop = asyncio.new_event_loop()
-        self.pt_app = PromptSession(**options)
+        if not _use_simple_prompt:
+            self.pt_loop = asyncio.new_event_loop()
+            self.pt_app = PromptSession(**options)
 
     def cmdloop(self, intro=None):
         """Repeatedly issue a prompt, accept input, parse an initial prefix
         off the received input, and dispatch to action methods, passing them
         the remainder of the line as argument.
 
         override the same methods from cmd.Cmd to provide prompt toolkit replacement.
         """
         if not self.use_rawinput:
             raise ValueError('Sorry ipdb does not support use_rawinput=False')
 
         # In order to make sure that prompt, which uses asyncio doesn't
         # interfere with applications in which it's used, we always run the
         # prompt itself in a different thread (we can't start an event loop
         # within an event loop). This new thread won't have any event loop
         # running, and here we run our prompt-loop.
         self.preloop()
 
         try:
             if intro is not None:
                 self.intro = intro
             if self.intro:
                 print(self.intro, file=self.stdout)
             stop = None
             while not stop:
                 if self.cmdqueue:
                     line = self.cmdqueue.pop(0)
                 else:
                     self._ptcomp.ipy_completer.namespace = self.curframe_locals
                     self._ptcomp.ipy_completer.global_namespace = self.curframe.f_globals
 
                     # Run the prompt in a different thread.
-                    try:
-                        line = self.thread_executor.submit(self.pt_app.prompt).result()
-                    except EOFError:
-                        line = "EOF"
+                    if not _use_simple_prompt:
+                        try:
+                            line = self.thread_executor.submit(
+                                self.pt_app.prompt
+                            ).result()
+                        except EOFError:
+                            line = "EOF"
+                    else:
+                        line = input("ipdb> ")
 
                 line = self.precmd(line)
                 stop = self.onecmd(line)
                 stop = self.postcmd(stop, line)
             self.postloop()
         except Exception:
             raise
 
     def do_interact(self, arg):
         ipshell = embed.InteractiveShellEmbed(
             config=self.shell.config,
             banner1="*interactive*",
             exit_msg="*exiting interactive console...*",
         )
         global_ns = self.curframe.f_globals
         ipshell(
             module=sys.modules.get(global_ns["__name__"], None),
             local_ns=self.curframe_locals,
         )
 
 
 def set_trace(frame=None):
     """
     Start debugging from `frame`.
 
     If frame is not specified, debugging starts from caller's frame.
     """
     TerminalPdb().set_trace(frame or sys._getframe().f_back)
 
 
 if __name__ == '__main__':
     import pdb
     # IPython.core.debugger.Pdb.trace_dispatch shall not catch
     # bdb.BdbQuit. When started through __main__ and an exception
     # happened after hitting "c", this is needed in order to
     # be able to quit the debugging session (see #9950).
     old_trace_dispatch = pdb.Pdb.trace_dispatch
     pdb.Pdb = TerminalPdb  # type: ignore
     pdb.Pdb.trace_dispatch = old_trace_dispatch  # type: ignore
     pdb.main()

docs/source/interactive/shell.rst

@@ -1,214 +1,214 b''
-.. _ipython_as_shell:
 
 .. note::
 
    This page has been kept for historical reason. You most likely want to use
    `Xonsh <https://xon.sh/>`__ instead of this.
 
+.. _ipython_as_shell:
 
 =========================
 IPython as a system shell
 =========================
 
 
 
 Overview
 ========
 
 It is possible to adapt IPython for system shell usage. In the past, IPython
 shipped a special 'sh' profile for this purpose, but it had been quarantined
 since 0.11 release, and in 1.0 it was removed altogether. Nevertheless, much
 of this section relies on machinery which does not require a custom profile.
 
 You can set up your own 'sh' :ref:`profile <Profiles>` to be different from
 the default profile such that:
 
  * Prompt shows the current directory (see `Prompt customization`_)
  * Make system commands directly available (in alias table) by running the
    ``%rehashx`` magic. If you install new programs along your PATH, you might
    want to run ``%rehashx`` to update the alias table
  * turn ``%autocall`` to full mode
 
 
 Environment variables
 =====================
 
 Rather than manipulating os.environ directly, you may like to use the magic
 `%env` command.  With no arguments, this displays all environment variables
 and values.  To get the value of a specific variable, use `%env var`.  To set
 the value of a specific variable, use `%env foo bar`, `%env foo=bar`.  By
 default values are considered to be strings so quoting them is unnecessary.
 However, Python variables are expanded as usual in the magic command, so
 `%env foo=$bar` means "set the environment variable foo to the value of the
 Python variable `bar`".
 
 Aliases
 =======
 
 Once you run ``%rehashx``, all of your $PATH has been loaded as IPython aliases,
 so you should be able to type any normal system command and have it executed.
 See ``%alias?``  and ``%unalias?`` for details on the alias facilities. See also
 ``%rehashx?`` for details on the mechanism used to load $PATH.
 
 .. warning::
 
    See info at the top of the page. You most likely want to use
    `Xonsh <https://xon.sh/>`__ instead of this.
 
 Directory management
 ====================
 
 Since each command passed by IPython to the underlying system is executed
 in a subshell which exits immediately, you can NOT use !cd to navigate
 the filesystem.
 
 IPython provides its own builtin ``%cd`` magic command to move in the
 filesystem (the % is not required with automagic on). It also maintains
 a list of visited directories (use ``%dhist`` to see it) and allows direct
 switching to any of them. Type ``cd?`` for more details.
 
 ``%pushd``, ``%popd`` and ``%dirs`` are provided for directory stack handling.
 
 
 Prompt customization
 ====================
 
 See :ref:`custom_prompts`.
 
 
 .. _string_lists:
 
 String lists
 ============
 
 String lists (IPython.utils.text.SList) are handy way to process output
 from system commands. They are produced by ``var = !cmd`` syntax.
 
 First, we acquire the output of 'ls -l'::
 
     [Q:doc/examples]|2> lines = !ls -l
      ==
     ['total 23',
      '-rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py',
      '-rw-rw-rw- 1 ville None 1927 Sep 30  2006 example-embed-short.py',
      '-rwxrwxrwx 1 ville None 4606 Sep  1 17:15 example-embed.py',
      '-rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py',
      '-rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py',
      '-rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py',
      '-rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc']
 
 Now, let's take a look at the contents of 'lines' (the first number is
 the list element number)::
 
     [Q:doc/examples]|3> lines
                     <3> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
 
     0: total 23
     1: -rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py
     2: -rw-rw-rw- 1 ville None 1927 Sep 30  2006 example-embed-short.py
     3: -rwxrwxrwx 1 ville None 4606 Sep  1 17:15 example-embed.py
     4: -rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py
     5: -rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py
     6: -rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py
     7: -rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc
 
 Now, let's filter out the 'embed' lines::
 
     [Q:doc/examples]|4> l2 = lines.grep('embed',prune=1)
     [Q:doc/examples]|5> l2
                     <5> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
 
     0: total 23
     1: -rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py
     2: -rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py
     3: -rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py
     4: -rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py
     5: -rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc
 
 Now, we want strings having just file names and permissions::
 
     [Q:doc/examples]|6> l2.fields(8,0)
                     <6> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:
 
     0: total
     1: example-demo.py -rw-rw-rw-
     2: example-gnuplot.py -rwxrwxrwx
     3: extension.py -rwxrwxrwx
     4: seteditor.py -rwxrwxrwx
     5: seteditor.pyc -rwxrwxrwx
 
 Note how the line with 'total' does not raise IndexError.
 
 If you want to split these (yielding lists), call fields() without
 arguments::
 
     [Q:doc/examples]|7> _.fields()
                     <7>
     [['total'],
      ['example-demo.py', '-rw-rw-rw-'],
      ['example-gnuplot.py', '-rwxrwxrwx'],
      ['extension.py', '-rwxrwxrwx'],
      ['seteditor.py', '-rwxrwxrwx'],
      ['seteditor.pyc', '-rwxrwxrwx']]
 
 If you want to pass these separated with spaces to a command (typical
 for lists if files), use the .s property::
 
 
     [Q:doc/examples]|13> files = l2.fields(8).s
     [Q:doc/examples]|14> files
                     <14> 'example-demo.py example-gnuplot.py extension.py seteditor.py seteditor.pyc'
     [Q:doc/examples]|15> ls $files
     example-demo.py  example-gnuplot.py  extension.py  seteditor.py  seteditor.pyc
 
 SLists are inherited from normal Python lists, so every list method is
 available::
 
     [Q:doc/examples]|21> lines.append('hey')
 
 
 Real world example: remove all files outside version control
 ------------------------------------------------------------
 
 First, capture output of "hg status"::
 
     [Q:/ipython]|28> out = !hg status
      ==
     ['M IPython\\extensions\\ipy_kitcfg.py',
      'M IPython\\extensions\\ipy_rehashdir.py',
     ...
      '? build\\lib\\IPython\\Debugger.py',
      '? build\\lib\\IPython\\extensions\\InterpreterExec.py',
      '? build\\lib\\IPython\\extensions\\InterpreterPasteInput.py',
     ...
 
 (lines starting with ? are not under version control).
 
 ::
 
     [Q:/ipython]|35> junk = out.grep(r'^\?').fields(1)
     [Q:/ipython]|36> junk
                 <36> SList (.p, .n, .l, .s, .grep(), .fields() availab
     ...
     10: build\bdist.win32\winexe\temp\_ctypes.py
     11: build\bdist.win32\winexe\temp\_hashlib.py
     12: build\bdist.win32\winexe\temp\_socket.py
 
 Now we can just remove these files by doing 'rm $junk.s'.
 
 The .n, .s, .p properties
 -------------------------
 
 Properties of `SList <https://ipython.readthedocs.io/en/stable/api/generated/IPython.utils.text.html?highlight=SList#IPython.utils.text.SList>`_ wrapper
 provide a convenient ways to use contained text in different formats:
 
 * ``.n`` returns (original) string with lines separated by a newline
 * ``.s`` returns string with lines separated by single space (for
   convenient passing to system commands)
 * ``.p`` returns list of "path" objects from detected file names
 
 .. error::
 
    You went too far scroll back up. You most likely want to use
    `Xonsh <https://xon.sh/>`__ instead of this.
 

docs/source/whatsnew/version7.rst

@@ -1,1797 +1,1798 b''
 ============
  7.x Series
 ============
 
 .. _version 7.34:
 
 IPython 7.34
 ============
 
 This version contains a single fix:  fix uncaught BdbQuit exceptions on ipdb
 exit :ghpull:`13668`
 
 
 .. _version 7.33:
 
 IPython 7.33
 ============
 
  - Allow IPython hooks to receive current cell ids when frontend support it. See
    :ghpull:`13600`
 
  - ``?`` does not trigger the insertion of a new cell anymore as most frontend
    allow proper multiline edition. :ghpull:`13625`
 
 
 .. _version 7.32:
 
 IPython 7.32
 ============
 
 
 
 Autoload magic lazily
 ---------------------
 
 The ability to configure magics to be lazily loaded has been added to IPython.
 See the ``ipython --help-all`` section on ``MagicsManager.lazy_magic``.
 One can now use::
 
     c.MagicsManager.lazy_magics = {
               "my_magic": "slow.to.import",
               "my_other_magic": "also.slow",
     }
 
 And on first use of ``%my_magic``, or corresponding cell magic, or other line magic,
 the corresponding ``load_ext`` will be called just before trying to invoke the magic.
 
 Misc
 ----
 
  - Update sphinxify  for Docrepr 0.2.0  :ghpull:`13503`.
  - Set co_name for cells run line by line (to fix debugging with Python 3.10)
    :ghpull:`13535`
 
 
 Many thanks to all the contributors to this release. You can find all individual
 contributions to this milestone `on github
 <https://github.com/ipython/ipython/milestone/99>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries.
 
 .. _version 7.31:
 
 IPython 7.31
 ============
 
 IPython 7.31 brings a couple of backports and fixes from the 8.0 branches,
 it is likely one of the last releases of the 7.x series, as 8.0 will probably be released
 between this release and what would have been 7.32.
 
 Please test 8.0 beta/rc releases in addition to this release.
 
 This Releases:
  - Backport some fixes for Python 3.10 (:ghpull:`13412`)
  - use full-alpha transparency on dvipng rendered LaTeX (:ghpull:`13372`)
 
 Many thanks to all the contributors to this release. You can find all individual
 contributions to this milestone `on github
 <https://github.com/ipython/ipython/milestone/95>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries.
 
 
 .. _version 7.30:
 
 IPython 7.30
 ============
 
 IPython 7.30 fixes a couple of bugs introduce in previous releases (in
 particular with respect to path handling), and introduce a few features and
 improvements:
 
 Notably we will highlight :ghpull:`13267` "Document that ``%run`` can execute
 notebooks and ipy scripts.", which is the first commit of Fernando Pérez since
 mid 2016 (IPython 5.1). If you are new to IPython, Fernando created IPython in
 2001. The other most recent contribution of Fernando to IPython itself was
 May 2018, by reviewing and merging PRs. I want to note that Fernando is still
 active but mostly as a mentor and leader of the whole Jupyter organisation, but
 we're still happy to see him contribute code !
 
 :ghpull:`13290` "Use sphinxify (if available) in object_inspect_mime path"
 should allow richer Repr of docstrings when using jupyterlab inspector.
 
 :ghpull:`13311` make the debugger use ``ThreadPoolExecutor`` for debugger cmdloop.
 This should fix some issues/infinite loop, but let us know if you come across
 any regressions. In particular this fixes issues with `kmaork/madbg <https://github.com/kmaork/madbg>`_,
 a remote debugger for IPython.
 
 Note that this is likely the ante-penultimate release of IPython 7.x as a stable
 branch, as I hope to release IPython 8.0 as well as IPython 7.31 next
 month/early 2022.
 
 IPython 8.0 will drop support for Python 3.7, removed nose as a dependency, and
 7.x will only get critical bug fixes with 8.x becoming the new stable. This will
 not be possible without `NumFOCUS Small Development Grants
 <https://numfocus.org/programs/small-development-grants>`_ Which allowed us to
 hire `Nikita Kniazev <https://github.com/Kojoley>`_ who provide Python and C++
 help and contracting work.
 
 
 Many thanks to all the contributors to this release. You can find all individual
 contributions to this milestone `on github
 <https://github.com/ipython/ipython/milestone/94?closed=1>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries.
 
 
 .. _version 7.29:
 
 IPython 7.29
 ============
 
 
 IPython 7.29 brings a couple of new functionalities to IPython and a number of bugfixes.
 It is one of the largest recent release, relatively speaking, with close to 15 Pull Requests.
 
 
  - fix an issue where base64 was returned instead of bytes when showing figures :ghpull:`13162`
  - fix compatibility with PyQt6, PySide 6 :ghpull:`13172`. This may be of
    interest if you are running on Apple Silicon as only qt6.2+ is natively
    compatible.
  - fix matplotlib qtagg eventloop :ghpull:`13179`
  - Multiple docs fixes, typos, ... etc.
  - Debugger will now exit by default on SigInt :ghpull:`13218`, this will be
    useful in notebook/lab if you forgot to exit the debugger. "Interrupt Kernel"
    will now exist the debugger.
 
 It give Pdb the ability to skip code in decorators. If functions contain a
 special value names ``__debuggerskip__ = True|False``, the function will not be
 stepped into, and Pdb will step into lower frames only if the value is set to
 ``False``. The exact behavior is still likely to have corner cases and will be
 refined in subsequent releases. Feedback welcome. See the debugger module
 documentation for more info. Thanks to the `D. E. Shaw
 group <https://deshaw.com/>`__ for funding this feature.
 
 The main branch of IPython is receiving a number of changes as we received a
 `NumFOCUS SDG <https://numfocus.org/programs/small-development-grants>`__
 ($4800), to help us finish replacing ``nose`` by ``pytest``, and make IPython
 future proof with an 8.0 release.
 
 
 Many thanks to all the contributors to this release. You can find all individual
 contributions to this milestone `on github
 <https://github.com/ipython/ipython/milestone/93>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries.
 
 
 .. _version 7.28:
 
 IPython 7.28
 ============
 
 
 IPython 7.28 is again a minor release that mostly bring bugfixes, and couple of
 improvement. Many thanks to MrMino, who again did all the work this month, and
 made a number of documentation improvements.
 
 Here is a non-exhaustive list of changes,
 
 Fixes:
 
  - async with doesn't allow newlines :ghpull:`13090`
  - Dynamically changing to vi mode via %config magic) :ghpull:`13091`
 
 Virtualenv handling fixes:
 
  - init_virtualenv now uses Pathlib :ghpull:`12548`
  - Fix Improper path comparison of virtualenv directories :ghpull:`13140`
  - Fix virtual environment user warning for lower case pathes :ghpull:`13094`
  - Adapt to all sorts of drive names for cygwin :ghpull:`13153`
 
 New Features:
 
  - enable autoplay in embed YouTube player :ghpull:`13133`
 
  Documentation:
 
  - Fix formatting for the core.interactiveshell documentation :ghpull:`13118`
  - Fix broken ipyparallel's refs :ghpull:`13138`
  - Improve formatting of %time documentation :ghpull:`13125`
  - Reword the YouTubeVideo autoplay WN :ghpull:`13147`
 
 
 Highlighted features
 --------------------
 
 
 ``YouTubeVideo`` autoplay and the ability to add extra attributes to ``IFrame``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You can add any extra attributes to the ``<iframe>`` tag using the new
 ``extras`` argument in the ``IFrame`` class. For example::
 
     In [1]: from IPython.display import IFrame
 
     In [2]: IFrame(src="src", width=300, height=300, extras=['loading="eager"'])
 
 The above cells will result in the following HTML code being displayed in a
 notebook::
 
     <iframe
         width="300"
         height="300"
         src="src"
         frameborder="0"
         allowfullscreen
         loading="eager"
     ></iframe>
 
 Related to the above, the ``YouTubeVideo`` class now takes an
 ``allow_autoplay`` flag, which sets up the iframe of the embedded YouTube video
 such that it allows autoplay.
 
 .. note::
     Whether this works depends on the autoplay policy of the browser rendering
     the HTML allowing it. It also could get blocked by some browser extensions.
 
 Try it out!
+
 ::
 
     In [1]: from IPython.display import YouTubeVideo
 
     In [2]: YouTubeVideo("dQw4w9WgXcQ", allow_autoplay=True)
 
 
 
 Thanks
 ------
 
 Many thanks to all the contributors to this release. You can find all individual
 contributions to this milestone `on github
 <https://github.com/ipython/ipython/milestone/92>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries.
 
 
 .. _version 7.27:
 
 IPython 7.27
 ============
 
 IPython 7.27 is a minor release that fixes a couple of issues and compatibility.
 
 - Add support for GTK4 :ghpull:`131011`
 - Add support for Qt6 :ghpull:`13085`
 - Fix an issue with pip magic on windows :ghpull:`13093`
 
 Thanks
 ------
 
 Many thanks to all the contributors to this release. You can find all individual
 contributions to this milestone `on github
 <https://github.com/ipython/ipython/milestone/91>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries.
 
 .. _version 7.26:
 
 IPython 7.26
 ============
 
 IPython 7.26 is a minor release that fixes a couple of issues, updates in API
 and Copyright/Licenses issues around various part of the codebase.
 
 We'll highlight `this issue <https://github.com/ipython/ipython/issues/13039>`
 pointing out we were including and refereeing to code from Stack Overflow which
 was CC-BY-SA, hence incompatible with the BSD license of IPython. This lead us
 to a rewriting of the corresponding logic which in our case was done in a more
 efficient way (in our case we were searching string prefixes instead of full
 strings).
 
 You will notice also a number of documentation improvements and cleanup.
 
 Of particular interest are the following Pull-requests:
 
 
  - The IPython directive now uses Sphinx logging for warnings. :ghpull:`13030`.
  - Add expiry days option to pastebin magic and change http protocol to https.
    :ghpull:`13056`
  - Make Ipython.utils.timing work with jupyterlite :ghpull:`13050`.
 
 Pastebin magic expiry days option
 ---------------------------------
 
 The Pastebin magic now has ``-e`` option to determine 
 the number of days for paste expiration. For example
 the paste that created with ``%pastebin -e 20 1`` magic will
 be available for next 20 days.
 
 
 
 
 
 Thanks
 ------
 
 Many thanks to all the contributors to this release and in particular MrMino who
 is doing most of the work those days. You can find all individual contributions
 to this milestone `on github <https://github.com/ipython/ipython/milestone/90>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries.
 
 
 .. _version 7.25:
 
 IPython 7.25
 ============
 
 IPython 7.25 is a minor release that contains a single bugfix, which is highly
 recommended for all users of ipdb, ipython debugger %debug magic and similar.
 
 Issuing commands like ``where`` from within the debugger would reset the
 local variables changes made by the user. It is interesting to look at the root
 cause of the issue as accessing an attribute (``frame.f_locals``) would trigger
 this side effects.
 
 Thanks in particular to the patience from the reporters at D.E. Shaw for their
 initial bug report that was due to a similar coding oversight in an extension,
 and who took time to debug and narrow down the problem.
 
 Thanks
 ------
 
 Many thanks to all the contributors to this release you can find all individual
 contributions to this milestone `on github <https://github.com/ipython/ipython/milestone/89>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries.
 
 
 .. _version 7.24:
 
 IPython 7.24
 ============
 
 Third release of IPython for 2021, mostly containing bug fixes. A couple of not
 typical updates:
 
 Misc
 ----
 
 
  - Fix an issue where ``%recall`` would both succeeded and print an error message
    it failed. :ghpull:`12952`
  - Drop support for NumPy 1.16 – practically has no effect beyond indicating in
    package metadata that we do not support it. :ghpull:`12937`
 
 Debugger improvements
 ---------------------
 
 The debugger (and ``%debug`` magic) have been improved and can skip or hide frames
 originating from files that are not writable to the user, as these are less
 likely to be the source of errors, or be part of system files this can be a useful
 addition when debugging long errors.
 
 In addition to the global ``skip_hidden True|False`` command, the debugger has
 gained finer grained control of predicates as to whether to a frame should be
 considered hidden. So far 3 predicates are available :
 
   - ``tbhide``: frames containing the local variable ``__tracebackhide__`` set to
     True.
   - ``readonly``: frames originating from readonly files, set to False.
   - ``ipython_internal``: frames that are likely to be from IPython internal
     code, set to True.
 
 You can toggle individual predicates during a session with
 
 .. code-block::
 
    ipdb> skip_predicates readonly True
 
 Read-only files will now be considered hidden frames.
 
 
 You can call ``skip_predicates`` without arguments to see the states of current
 predicates:
 
 .. code-block::
 
     ipdb> skip_predicates
     current predicates:
         tbhide : True
         readonly : False
         ipython_internal : True
 
 If all predicates are set to ``False``,  ``skip_hidden`` will practically have
 no effect. We attempt to warn you when all predicates are False.
 
 Note that the ``readonly`` predicate may increase disk access as we check for
 file access permission for all frames on many command invocation, but is usually
 cached by operating systems. Let us know if you encounter any issues.
 
 As the IPython debugger does not use the traitlets infrastructure for
 configuration, by editing your ``.pdbrc`` files and appending commands you would
 like to be executed just before entering the interactive prompt. For example:
 
 
 .. code::
 
     # file : ~/.pdbrc
     skip_predicates readonly True
     skip_predicates tbhide False
 
 Will hide read only frames by default and show frames marked with
 ``__tracebackhide__``.
 
 
 
 
 Thanks
 ------
 
 Many thanks to all the contributors to this release you can find all individual
 contributions to this milestone `on github <https://github.com/ipython/ipython/milestone/87>`__.
 
 Thanks as well to the `D. E. Shaw group <https://deshaw.com/>`__ for sponsoring
 work on IPython and related libraries, in particular above mentioned
 improvements to the debugger.
 
 
 
 
 .. _version 7.23:
 
 IPython 7.23 and 7.23.1
 =======================
 
 
 Third release of IPython for 2021, mostly containing bug fixes. A couple of not
 typical updates:
 
  - We moved to GitHub actions away from Travis-CI, the transition may not be
    100% complete (not testing on nightly anymore), but as we ran out of
    Travis-Ci hours on the IPython organisation that was a necessary step.
    :ghpull:`12900`.
 
  - We have a new dependency: ``matplotlib-inline``, which try to extract
    matplotlib inline backend specific behavior. It is available on PyPI and
    conda-forge thus should not be a problem to upgrade to this version. If you
    are a package maintainer that might be an extra dependency to package first.
    :ghpull:`12817` (IPython 7.23.1 fix a typo that made this change fail)
 
 In the addition/new feature category, ``display()`` now have a ``clear=True``
 option to clear the display if any further outputs arrives, allowing users to
 avoid having to use ``clear_output()`` directly. :ghpull:`12823`.
 
 In bug fixes category, this release fix an issue when printing tracebacks
 containing Unicode characters :ghpull:`12758`.
 
 In code cleanup category :ghpull:`12932` remove usage of some deprecated
 functionality for compatibility with Python 3.10.
 
 
 
 Thanks
 ------
 
 Many thanks to all the contributors to this release you can find all individual
 contributions to this milestone `on github <https://github.com/ipython/ipython/milestone/86>`__.
 In particular MrMino for responding to almost all new issues, and triaging many
 of the old ones, as well as takluyver, minrk, willingc for reacting quikly when
 we ran out of CI Hours.
 
 Thanks as well to organisations, QuantStack (martinRenou and SylvainCorlay) for
 extracting matplotlib inline backend into its own package, and the `D. E. Shaw group
 <https://deshaw.com/>`__ for sponsoring work on IPython and related libraries.
 
 
 .. _version 7.22:
 
 IPython 7.22
 ============
 
 Second release of IPython for 2021, mostly containing bug fixes. Here is a quick
 rundown of the few changes.
 
 - Fix some ``sys.excepthook`` shenanigan when embedding with qt, recommended if
   you – for example – use `napari <https://napari.org>`__. :ghpull:`12842`.
 - Fix bug when using the new ipdb ``%context`` magic :ghpull:`12844`
 - Couples of deprecation cleanup :ghpull:`12868`
 - Update for new dpast.com api if you use the ``%pastbin`` magic. :ghpull:`12712`
 - Remove support for numpy before 1.16. :ghpull:`12836`
 
 
 Thanks
 ------
 
 We have a new team member that you should see more often on the IPython
 repository, Błażej Michalik (@MrMino) have been doing regular contributions to
 IPython, and spent time replying to many issues and guiding new users to the
 codebase; they now have triage permissions to the IPython repository and we'll
 work toward giving them more permission in the future.
 
 Many thanks to all the contributors to this release you can find all individual
 contributions to this milestone `on github <https://github.com/ipython/ipython/milestone/84>`__.
 
 Thanks as well to organisations, QuantStack for working on debugger
 compatibility for Xeus_python, and the `D. E. Shaw group
 <https://deshaw.com/>`__ for sponsoring work on IPython and related libraries.
 
 .. _version 721:
 
 IPython 7.21
 ============
 
 IPython 7.21 is the first release we have back on schedule of one release every
 month; it contains a number of minor fixes and improvements, notably, the new
 context command for ipdb
 
 
 New "context" command in ipdb
 -----------------------------
 
 It is now possible to change the number of lines shown in the backtrace
 information in ipdb using "context" command. :ghpull:`12826`
 
 (thanks @MrMino, there are other improvement from them on master).
 
 Other notable changes in IPython 7.21
 -------------------------------------
 
 - Fix some issues on new osx-arm64 :ghpull:`12804`, :ghpull:`12807`. 
 - Compatibility with Xeus-Python for debugger protocol, :ghpull:`12809`
 - Misc docs fixes for compatibility and uniformity with Numpydoc.
   :ghpull:`12824`
 
 
 Thanks
 ------
 
 Many thanks to all the contributors to this release you can find all individual
 contribution to this milestone `on github <https://github.com/ipython/ipython/milestone/83>`__.
 
 
 .. _version 720:
 
 IPython 7.20
 ============
 
 IPython 7.20 is the accumulation of 3 month of work on IPython, spacing between
 IPython release have been increased from the usual once a month for various
 reason.
 
    - Mainly as I'm too busy and the effectively sole maintainer, and
    - Second because not much changes happened before mid December.
 
 The main driver for this release was the new version of Jedi 0.18 breaking API;
 which was taken care of in the master branch early in 2020 but not in 7.x as I
 though that by now 8.0 would be out.
 
 The inclusion of a resolver in pip did not help and actually made things worse.
 If usually I would have simply pinned Jedi to ``<0.18``; this is not a solution
 anymore as now pip is free to install Jedi 0.18, and downgrade IPython.
 
 I'll do my best to keep the regular release, but as the 8.0-dev branch and 7.x
 are starting to diverge this is becoming difficult in particular with my limited
 time, so if you have any cycles to spare I'll appreciate your help to respond to
 issues and pushing 8.0 forward.
 
 Here are thus some of the changes for IPython 7.20.
 
   - Support for PyQt5 >= 5.11 :ghpull:`12715`
   - ``%reset`` remove imports more agressively :ghpull:`12718`
   - fix the ``%conda`` magic :ghpull:`12739`
   - compatibility with Jedi 0.18, and bump minimum Jedi version. :ghpull:`12793`
 
 
 .. _version 719:
 
 IPython 7.19
 ============
 
 IPython 7.19 accumulative two month of works, bug fixes and improvements, there
 was exceptionally no release last month.
 
   - Fix to restore the ability to specify more than one extension using command
     line flags when using traitlets 5.0 :ghpull:`12543`
   - Docs docs formatting that make the install commands work on zsh
     :ghpull:`12587`
   - Always display the last frame in tracebacks even if hidden with
     ``__tracebackhide__`` :ghpull:`12601`
   - Avoid an issue where a callback can be registered multiple times.
     :ghpull:`12625`
   - Avoid an issue in debugger mode where frames changes could be lost.
     :ghpull:`12627`
 
   - Never hide the frames that invoke a debugger, even if marked as hidden by
     ``__tracebackhide__`` :ghpull:`12631`
   - Fix calling the debugger in a recursive manner :ghpull:`12659`
 
 
 A number of code changes have landed on master and we are getting close to
 enough new features and codebase improvement that a 8.0 start to make sens.
 For downstream packages, please start working on migrating downstream testing
 away from iptest and using pytest, as nose will not work on Python 3.10 and we
 will likely start removing it as a dependency for testing.
 
 .. _version 718:
 
 IPython 7.18
 ============
 
 IPython 7.18 is a minor release that mostly contains bugfixes.
 
  - ``CRLF`` is now handled by magics my default; solving some issues due to copy
    pasting on windows. :ghpull:`12475`
 
  - Requiring pexpect ``>=4.3`` as we are Python 3.7+ only and earlier version of
    pexpect will be incompatible. :ghpull:`12510`
 
  - Minimum jedi version is now 0.16. :ghpull:`12488`
 
 
 
 .. _version 717:
 
 IPython 7.17
 ============
 
 IPython 7.17 brings a couple of new improvements to API and a couple of user
 facing changes to make the terminal experience more user friendly.
 
 :ghpull:`12407` introduces the ability to pass extra argument to the IPython
 debugger class; this is to help a new project from ``kmaork``
 (https://github.com/kmaork/madbg) to feature a fully remote debugger.
 
 :ghpull:`12410` finally remove support for 3.6, while the codebase is still
 technically compatible; IPython will not install on Python 3.6.
 
 lots of work on the debugger and hidden frames from ``@impact27`` in
 :ghpull:`12437`, :ghpull:`12445`, :ghpull:`12460` and in particular
 :ghpull:`12453` which make the debug magic more robust at handling spaces.
 
 Biggest API addition is code transformation which is done before code execution;
 IPython allows a number of hooks to catch non-valid Python syntax (magic, prompt
 stripping...etc). Transformers are usually called many time; typically:
 
  - When trying to figure out whether the code is complete and valid (should we
    insert a new line or execute ?)
  - During actual code execution pass before giving the code to Python's
    ``exec``.
 
 This lead to issues when transformer might have had side effects; or do external
 queries. Starting with IPython 7.17 you can expect your transformer to be called
 less time.
 
 Input transformers are now called only once in the execution path of
 `InteractiveShell`, allowing to register transformer that potentially have side
 effects (note that this is not recommended). Internal methods `should_run_async`, and
 `run_cell_async` now take a recommended optional `transformed_cell`, and
 `preprocessing_exc_tuple` parameters that will become mandatory at some point in
 the future; that is to say cells need to be explicitly transformed to be valid
 Python syntax ahead of trying to run them. :ghpull:`12440`;
 
 ``input_transformers`` can now also have an attribute ``has_side_effects`` set
 to `True`, when this attribute is present; this  will prevent the transformers
 from being ran when IPython is trying to guess whether the user input is
 complete. Note that this may means you will need to explicitly execute in some
 case where your transformations are now not ran; but will not affect users with
 no custom extensions.
 
 
 API Changes
 -----------
 
 Change of API and exposed objects automatically detected using `frappuccino
 <https://pypi.org/project/frappuccino/>`_
 
 
  The following items are new since 7.16.0::
 
      + IPython.core.interactiveshell.InteractiveShell.get_local_scope(self, stack_depth)
 
  The following signatures differ since 7.16.0::
 
      - IPython.core.interactiveshell.InteractiveShell.run_cell_async(self, raw_cell, store_history=False, silent=False, shell_futures=True)
      + IPython.core.interactiveshell.InteractiveShell.run_cell_async(self, raw_cell, store_history=False, silent=False, shell_futures=True, *, transformed_cell=None, preprocessing_exc_tuple=None)
 
      - IPython.core.interactiveshell.InteractiveShell.should_run_async(self, raw_cell)
      + IPython.core.interactiveshell.InteractiveShell.should_run_async(self, raw_cell, *, transformed_cell=None, preprocessing_exc_tuple=None)
 
      - IPython.terminal.debugger.TerminalPdb.pt_init(self)
      + IPython.terminal.debugger.TerminalPdb.pt_init(self, pt_session_options=None)
 
 This method was added::
 
      + IPython.core.interactiveshell.InteractiveShell.get_local_scope
 
 Which is now also present on subclasses::
 
      + IPython.terminal.embed.InteractiveShellEmbed.get_local_scope
      + IPython.terminal.interactiveshell.TerminalInteractiveShell.get_local_scope
 
 
 .. _version 716:
 
 IPython 7.16.1, 7.16.2
 ======================
 
 IPython 7.16.1 was release immediately after 7.16.0 to fix a conda packaging issue.
 The source is identical to 7.16.0 but the file permissions in the tar are different.
 
 IPython 7.16.2 pins jedi dependency to "<=0.17.2" which should prevent some
 issues for users still on python 3.6. This may not be sufficient as pip may
 still allow to downgrade IPython.
 
 Compatibility with Jedi > 0.17.2 was not added as this would have meant bumping
 the minimal version to >0.16.
 
 IPython 7.16
 ============
 
 
 The default traceback mode will now skip frames that are marked with
 ``__tracebackhide__ = True`` and show how many traceback frames have been
 skipped. This can be toggled by using :magic:`xmode` with the ``--show`` or
 ``--hide`` attribute. It will have no effect on non verbose traceback modes.
 
 The ipython debugger also now understands ``__tracebackhide__`` as well and will
 skip hidden frames when displaying. Movement up and down the stack will skip the
 hidden frames and will show how many frames were hidden. Internal IPython frames
 are also now hidden by default. The behavior can be changed with the
 ``skip_hidden`` while in the debugger, command and accepts "yes", "no", "true"
 and "false" case insensitive parameters.
 
 
 Misc Noticeable changes:
 ------------------------
 
 - Exceptions are now (re)raised when running notebooks via the :magic:`%run`, helping to catch issues in workflows and
   pipelines. :ghpull:`12301`
 - Fix inputhook for qt 5.15.0 :ghpull:`12355`
 - Fix wx inputhook :ghpull:`12375`
 - Add handling for malformed pathext env var (Windows) :ghpull:`12367`
 - use $SHELL in system_piped :ghpull:`12360` for uniform behavior with
   ipykernel.
 
 Reproducible Build
 ------------------
 
 IPython 7.15 reproducible build did not work, so we try again this month
 :ghpull:`12358`.
 
 
 API Changes
 -----------
 
 Change of API and exposed objects automatically detected using `frappuccino
 <https://pypi.org/project/frappuccino/>`_ (still in beta):
 
 
 The following items are new and mostly related to understanding ``__tracebackhide__``::
 
     + IPython.core.debugger.Pdb.do_down(self, arg)
     + IPython.core.debugger.Pdb.do_skip_hidden(self, arg)
     + IPython.core.debugger.Pdb.do_up(self, arg)
     + IPython.core.debugger.Pdb.hidden_frames(self, stack)
     + IPython.core.debugger.Pdb.stop_here(self, frame)
 
 
 The following items have been removed::
 
     - IPython.core.debugger.Pdb.new_do_down
     - IPython.core.debugger.Pdb.new_do_up
 
 Those were implementation details.
 
 
 .. _version 715:
 
 IPython 7.15
 ============
 
 IPython 7.15 brings a number of bug fixes and user facing improvements.
 
 Misc Noticeable changes:
 ------------------------
 
  - Long completion name have better elision in terminal :ghpull:`12284`
  - I've started to test on Python 3.9 :ghpull:`12307` and fix some errors.
  - Hi DPI scaling of figures when using qt eventloop :ghpull:`12314`
  - Document the ability to have systemwide configuration for IPython.
    :ghpull:`12328`
  - Fix issues with input autoformatting :ghpull:`12336`
  - ``IPython.core.debugger.Pdb`` is now interruptible (:ghpull:`12168`, in 7.14
    but forgotten in release notes)
  - Video HTML attributes (:ghpull:`12212`, in 7.14 but forgotten in release
    notes)
 
 Reproducible Build
 ------------------
 
 Starting with IPython 7.15, I am attempting to provide reproducible builds,
 that is to say you should be able from the source tree to generate an sdist
 and wheel that are identical byte for byte with the publish version on PyPI.
 
 I've only tested on a couple of machines so far and the process is relatively
 straightforward, so this mean that IPython not only have a deterministic build
 process, but also I have either removed, or put under control all effects of
 the build environments on the final artifact.  I encourage you to attempt the
 build process on your machine as documented in :ref:`core_developer_guide`
 and let me know if you do not obtain an identical artifact.
 
 While reproducible builds is critical to check that the supply chain of (open
 source) software has not been compromised, it can also help to speedup many
 of the build processes in large environment (conda, apt...) by allowing
 better caching of intermediate build steps.
 
 Learn more on `<https://reproducible-builds.org/>`_. `Reflections on trusting
 trust <https://dl.acm.org/doi/10.1145/358198.358210>`_ is also one of the
 cornerstone and recommended reads on this subject.
 
 .. note::
 
    The build commit from which the sdist is generated is also `signed
    <https://en.wikipedia.org/wiki/Digital_signature>`_, so you should be able to
    check it has not been compromised, and the git repository is a `merkle-tree
    <https://en.wikipedia.org/wiki/Merkle_tree>`_, you can check the consistency
    with `git-fsck <https://git-scm.com/docs/git-fsck>`_ which you likely `want
    to enable by default
    <https://gist.github.com/mbbx6spp/14b86437e794bffb4120>`_.
 
 NEP29: Last version to support Python 3.6
 -----------------------------------------
 
 IPython 7.15 will be the Last IPython version to officially support Python
 3.6, as stated by `NumPy Enhancement Proposal 29
 <https://numpy.org/neps/nep-0029-deprecation_policy.html>`_. Starting with
 next minor version of IPython I may stop testing on Python 3.6 and may stop
 publishing release artifacts that install on Python 3.6
 
 Highlighted features
 --------------------
 
 Highlighted features are not new, but seem to not be widely known, this
 section will help you discover in more narrative form what you can do with
 IPython.
 
 Increase Tab Completion Menu Height
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 In terminal IPython it is possible to increase the hight of the tab-completion
 menu. To do so set the value of
 :configtrait:`TerminalInteractiveShell.space_for_menu`, this will reserve more
 space at the bottom of the screen for various kind of menus in IPython including
 tab completion and searching in history. 
 
 Autoformat Code in the terminal
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 If you have a preferred code formatter, you can configure IPython to
 reformat your code. Set the value of
 :configtrait:`TerminalInteractiveShell.autoformatter` to for example ``'black'``
 and IPython will auto format your code when possible.
 
 
 .. _version 714:
 
 IPython 7.14
 ============
 
 IPython  7.14 is a minor release that fix a couple of bugs and prepare
 compatibility with new or future versions of some libraries. 
 
 Important changes:
 ------------------
 
  - Fix compatibility with Sphinx 3+ :ghpull:`12235`
  - Remove deprecated matplotlib parameter usage, compatibility with matplotlib
    3.3+ :`122250`
 
 Misc Changes
 ------------
 
  - set ``.py`` extension when editing current buffer in vi/emacs. :ghpull:`12167`
  - support for unicode identifiers in ``?``/``??`` :ghpull:`12208`
  - add extra options to the ``Video`` Rich objects :ghpull:`12212`
  - add pretty-printing to ``SimpleNamespace`` :ghpull:`12230`
 
 IPython.core.debugger.Pdb is now interruptible
 ----------------------------------------------
 
 A ``KeyboardInterrupt`` will now interrupt IPython's extended debugger, in order to make Jupyter able to interrupt it. (:ghpull:`12168`)
 
 Video HTML attributes
 ---------------------
 
 Add an option to `IPython.display.Video` to change the attributes of the HTML display of the video (:ghpull:`12212`)
 
 
 Pending deprecated imports
 --------------------------
 
 Many object present in ``IPython.core.display`` are there for internal use only,
 and should  already been imported from ``IPython.display`` by users and external
 libraries. Trying to import those from ``IPython.core.display`` is still possible
 but will trigger a
 deprecation warning in later versions of IPython and will become errors in the
 future. 
 
 This will simplify compatibility with other Python kernels (like Xeus-Python),
 and simplify code base. 
 
 
 
 
 .. _version 713:
 
 IPython 7.13
 ============
 
 IPython 7.13 is the final release of the 7.x branch since master is diverging
 toward an 8.0. Exiting new features have already been merged in 8.0 and will
 not be available on the 7.x branch. All the changes below have been backported
 from the master branch.
 
 
  - Fix inability to run PDB when inside an event loop :ghpull:`12141`
  - Fix ability to interrupt some processes on windows :ghpull:`12137`
  - Fix debugger shortcuts :ghpull:`12132`
  - improve tab completion when inside a string by removing irrelevant elements :ghpull:`12128`
  - Fix display of filename tab completion when the path is long :ghpull:`12122`
  - Many removal of Python 2 specific code path :ghpull:`12110`
  - displaying wav files do not require NumPy anymore, and is 5x to 30x faster :ghpull:`12113`
 
 See the list of all closed issues and pull request on `github
 <https://github.com/ipython/ipython/pulls?q=is%3Aclosed+milestone%3A7.13>`_.
 
 .. _version 712:
 
 IPython 7.12
 ============
 
 IPython 7.12 is a minor update that mostly brings code cleanup, removal of
 longtime deprecated function and a couple update to documentation cleanup as well.
 
 Notable changes are the following:
 
  - Exit non-zero when ipython is given a file path to run that doesn't exist :ghpull:`12074`
  - Test PR on ARM64 with Travis-CI :ghpull:`12073`
  - Update CI to work with latest Pytest :ghpull:`12086`
  - Add infrastructure to run ipykernel eventloop via trio :ghpull:`12097`
  - Support git blame ignore revs :ghpull:`12091`
  - Start multi-line ``__repr__`` s on their own line :ghpull:`12099`
 
 .. _version 7111:
 
 IPython 7.11.1
 ==============
 
 A couple of deprecated functions (no-op) have been reintroduces in py3compat as
 Cython was still relying on them, and will be removed in a couple of versions.
 
 .. _version 711:
 
 IPython 7.11
 ============
 
 IPython 7.11 received a couple of compatibility fixes and code cleanup.
 
 A number of function in the ``py3compat`` have been removed; a number of types
 in the IPython code base are now non-ambiguous and now always ``unicode``
 instead of ``Union[Unicode,bytes]``; many of the relevant code path have thus
 been simplified/cleaned and types annotation added.
 
 IPython support several verbosity level from exceptions. ``xmode plain`` now
 support chained exceptions. :ghpull:`11999`
 
 We are starting to remove ``shell=True`` in some usages of subprocess. While not directly
 a security issue (as IPython is made to run arbitrary code anyway) it is not good
 practice and we'd like to show the example. :ghissue:`12023`. This discussion
 was started by ``@mschwager`` thanks to a new auditing tool they are working on
 with duo-labs (`dlint <https://github.com/duo-labs/dlint>`_).
 
 Work around some bugs in Python 3.9 tokenizer :ghpull:`12057`
 
 IPython will now print its version after a crash. :ghpull:`11986`
 
 This is likely the last release from the 7.x series that will see new feature.
 The master branch will soon accept large code changes and thrilling new
 features; the 7.x branch will only start to accept critical bug fixes, and
 update dependencies.
 
 .. _version 7102:
 
 IPython 7.10.2
 ==============
 
 IPython 7.10.2 fix a couple of extra incompatibility between IPython, ipdb,
 asyncio and Prompt Toolkit 3.
 
 .. _version 7101:
 
 IPython 7.10.1
 ==============
 
 IPython 7.10.1 fix a couple of incompatibilities with Prompt toolkit 3 (please
 update Prompt toolkit to 3.0.2 at least), and fixes some interaction with
 headless IPython.
 
 .. _version 7100:
 
 IPython 7.10.0
 ==============
 
 IPython 7.10 is the first double digit minor release in the  last decade, and
 first since the release of IPython 1.0, previous double digit minor release was
 in August 2009.
 
 We've been trying to give you regular release on the last Friday of every month
 for a guaranty of rapid access to bug fixes and new features.
 
 Unlike the previous first few releases that have seen only a couple of code
 changes, 7.10 bring a number of changes, new features and bugfixes.
 
 Stop Support for Python 3.5 – Adopt NEP 29
 ------------------------------------------
 
 IPython has decided to follow the informational `NEP 29
 <https://numpy.org/neps/nep-0029-deprecation_policy.html>`_ which layout a clear
 policy as to which version of (C)Python and NumPy are supported.
 
 We thus dropped support for Python 3.5, and cleaned up a number of code path
 that were Python-version dependant. If you are on 3.5 or earlier pip should
 automatically give you the latest compatible version of IPython so you do not
 need to pin to a given version.
 
 Support for Prompt Toolkit 3.0
 ------------------------------
 
 Prompt Toolkit 3.0 was release a week before IPython 7.10 and introduces a few
 breaking changes. We believe IPython 7.10 should be compatible with both Prompt
 Toolkit 2.x and 3.x, though it has not been extensively tested with 3.x so
 please report any issues.
 
 
 Prompt Rendering Performance improvements
 -----------------------------------------
 
 Pull Request :ghpull:`11933` introduced an optimisation in the prompt rendering
 logic that should decrease the resource usage of IPython when using the
 _default_ configuration but could potentially introduce a regression of
 functionalities if you are using a custom prompt.
 
 We know assume if you haven't changed the default keybindings that the prompt
 **will not change** during the duration of your input – which is for example
 not true when using vi insert mode that switches between `[ins]` and `[nor]`
 for the current mode.
 
 If you are experiencing any issue let us know.
 
 Code autoformatting
 -------------------
 
 The IPython terminal can now auto format your code just before entering a new
 line or executing a command. To do so use the
 ``--TerminalInteractiveShell.autoformatter`` option and set it to ``'black'``;
 if black is installed IPython will use black to format your code when possible.
 
 IPython cannot always properly format your code; in particular it will
 auto formatting with *black* will only work if:
 
    - Your code does not contains magics or special python syntax.
 
    - There is no code after your cursor.
 
 The Black API is also still in motion; so this may not work with all versions of
 black.
 
 It should be possible to register custom formatter, though the API is till in
 flux.
 
 Arbitrary Mimetypes Handing in Terminal (Aka inline images in terminal)
 -----------------------------------------------------------------------
 
 When using IPython terminal it is now possible to register function to handle
 arbitrary mimetypes. While rendering non-text based representation was possible in
 many jupyter frontend; it was not possible in terminal IPython, as usually
 terminal are limited to displaying text. As many terminal these days provide
 escape sequences to display non-text; bringing this loved feature to IPython CLI
 made a lot of sens. This functionality will not only allow inline images; but
 allow opening of external program; for example ``mplayer`` to "display" sound
 files.
 
 So far only the hooks necessary for this are in place, but no default mime
 renderers added; so inline images will only be available via extensions. We will
 progressively enable these features by default in the next few releases, and
 contribution is welcomed.
 
 We welcome any feedback on the API. See :ref:`shell_mimerenderer` for more
 informations.
 
 This is originally based on work form in :ghpull:`10610` from @stephanh42
 started over two years ago, and still a lot need to be done.
 
 MISC
 ----
 
  - Completions can define their own ordering :ghpull:`11855`
  - Enable Plotting in the same cell than the one that import matplotlib
    :ghpull:`11916`
  - Allow to store and restore multiple variables at once :ghpull:`11930`
 
 You can see `all pull-requests <https://github.com/ipython/ipython/pulls?q=is%3Apr+milestone%3A7.10+is%3Aclosed>`_ for this release.
 
 API Changes
 -----------
 
 Change of API and exposed objects automatically detected using `frappuccino <https://pypi.org/project/frappuccino/>`_ (still in beta):
 
 The following items are new in IPython 7.10::
 
     + IPython.terminal.shortcuts.reformat_text_before_cursor(buffer, document, shell)
     + IPython.terminal.interactiveshell.PTK3
     + IPython.terminal.interactiveshell.black_reformat_handler(text_before_cursor)
     + IPython.terminal.prompts.RichPromptDisplayHook.write_format_data(self, format_dict, md_dict='None')
 
 The following items have been removed in 7.10::
 
     - IPython.lib.pretty.DICT_IS_ORDERED
 
 The following signatures differ between versions::
 
     - IPython.extensions.storemagic.restore_aliases(ip)
     + IPython.extensions.storemagic.restore_aliases(ip, alias='None')
 
 Special Thanks
 --------------
 
  - @stephanh42 who started the work on inline images in terminal 2 years ago
  - @augustogoulart who spent a lot of time triaging issues and responding to
    users.
  - @con-f-use who is my (@Carreau) first sponsor on GitHub, as a reminder if you
    like IPython, Jupyter and many other library of the SciPy stack you can
    donate to numfocus.org non profit
 
 .. _version 790:
 
 IPython 7.9.0
 =============
 
 IPython 7.9 is a small release with a couple of improvement and bug fixes.
 
  - Xterm terminal title should be restored on exit :ghpull:`11910`
  - special variables ``_``,``__``, ``___`` are not set anymore when cache size
    is 0 or less.  :ghpull:`11877`
  - Autoreload should have regained some speed by using a new heuristic logic to
    find all objects needing reload. This should avoid large objects traversal
    like pandas dataframes. :ghpull:`11876`
  - Get ready for Python 4. :ghpull:`11874`
  - `%env` Magic now has heuristic to hide potentially sensitive values :ghpull:`11896`
 
 This is a small release despite a number of Pull Request Pending that need to
 be reviewed/worked on. Many of the core developers have been busy outside of
 IPython/Jupyter and we thanks all contributor for their patience; we'll work on
 these as soon as we have time.
 
 
 .. _version780:
 
 IPython 7.8.0
 =============
 
 IPython 7.8.0 contain a few bugfix and 2 new APIs:
 
  - Enable changing the font color for LaTeX rendering :ghpull:`11840`
  - and Re-Expose some PDB API (see below)
 
 Expose Pdb API
 --------------
 
 Expose the built-in ``pdb.Pdb`` API. ``Pdb`` constructor arguments are generically
 exposed, regardless of python version.
 Newly exposed arguments:
 
 - ``skip`` - Python 3.1+
 - ``nosiginnt`` - Python 3.2+
 - ``readrc`` - Python 3.6+
 
 Try it out::
 
     from IPython.terminal.debugger import TerminalPdb
     pdb = TerminalPdb(skip=["skipthismodule"])
 
 
 See :ghpull:`11840`
 
 .. _version770:
 
 IPython 7.7.0
 =============
 
 IPython 7.7.0 contain multiple bug fixes and documentation updates; Here are a
 few of the outstanding issue fixed:
 
    - Fix a bug introduced in 7.6 where the ``%matplotlib`` magic would fail on
      previously acceptable arguments :ghpull:`11814`.
    - Fix the manage location on freebsd :ghpull:`11808`.
    - Fix error message about aliases after ``%reset`` call in ipykernel
      :ghpull:`11806`
    - Fix Duplication completions in emacs :ghpull:`11803`
 
 We are planning to adopt `NEP29 <https://github.com/numpy/numpy/pull/14086>`_
 (still currently in draft) which may make this minor version of IPython the
 last one to support Python 3.5 and will make the code base more aggressive
 toward removing compatibility with older versions of Python.
 
 GitHub now support to give only "Triage" permissions to users; if you'd like to
 help close stale issues and labels issues please reach to us with your GitHub
 Username and we'll add you to the triage team. It is a great way to start
 contributing and a path toward getting commit rights.
 
 .. _version761:
 
 IPython 7.6.1
 =============
 
 IPython 7.6.1 contain a critical bugfix in the ``%timeit`` magic, which would
 crash on some inputs as a side effect of :ghpull:`11716`. See :ghpull:`11812`
 
 
 .. _whatsnew760:
 
 IPython 7.6.0
 =============
 
 IPython 7.6.0 contains a couple of bug fixes and number of small features
 additions as well as some compatibility with the current development version of
 Python 3.8.
 
    - Add a ``-l`` option to :magic:`psearch` to list the available search
      types. :ghpull:`11672`
    - Support ``PathLike`` for ``DisplayObject`` and ``Image``. :ghpull:`11764`
    - Configurability of timeout in the test suite for slow platforms.
      :ghpull:`11756`
    - Accept any casing for matplotlib backend. :ghpull:`121748`
    - Properly skip test that requires numpy to be installed :ghpull:`11723`
    - More support for Python 3.8 and positional only arguments (pep570)
      :ghpull:`11720`
    - Unicode names for the completion are loaded lazily on first use which
      should decrease startup time. :ghpull:`11693`
    - Autoreload now update the types of reloaded objects; this for example allow
      pickling of reloaded objects. :ghpull:`11644`
    - Fix a bug where ``%%time`` magic would suppress cell output. :ghpull:`11716`
 
 
 Prepare migration to pytest (instead of nose) for testing
 ---------------------------------------------------------
 
 Most of the work between 7.5 and 7.6 was to prepare the migration from our
 testing framework to pytest. Most of the test suite should now work by simply
 issuing ``pytest`` from the root of the repository.
 
 The migration to pytest is just at its beginning. Many of our test still rely
 on IPython-specific plugins for nose using pytest (doctest using IPython syntax
 is one example of this where test appear as "passing", while no code has been
 ran). Many test also need to be updated like ``yield-test`` to be properly
 parametrized tests.
 
 Migration to pytest allowed me to discover a number of issues in our test
 suite; which was hiding a number of subtle issues – or not actually running
 some of the tests in our test suite – I have thus corrected many of those; like
 improperly closed resources; or used of deprecated features. I also made use of
 the ``pytest --durations=...`` to find some of our slowest test and speed them
 up (our test suite can now be up to 10% faster). Pytest as also a variety of
 plugins and flags which will make the code quality of IPython and the testing
 experience better.
 
 Misc
 ----
 
 We skipped the release of 7.6 at the end of May, but will attempt to get back
 on schedule. We are starting to think about making introducing backward
 incompatible change and start the 8.0 series.
 
 Special Thanks to Gabriel (@gpotter2 on GitHub), who among other took care many
 of the remaining task for 7.4 and 7.5, like updating the website.
 
 .. _whatsnew750:
 
 IPython 7.5.0
 =============
 
 IPython 7.5.0 consist mostly of bug-fixes, and documentation updates, with one
 minor new feature. The `Audio` display element can now be assigned an element
 id when displayed in browser. See :ghpull:`11670`
 
 The major outstanding bug fix correct a change of behavior that was introduce
 in 7.4.0 where some cell magics would not be able to access or modify global
 scope when using the ``@needs_local_scope`` decorator. This was typically
 encountered with the ``%%time`` and ``%%timeit`` magics. See :ghissue:`11659`
 and :ghpull:`11698`.
 
 .. _whatsnew740:
 
 IPython 7.4.0
 =============
 
 Unicode name completions
 ------------------------
 
 Previously, we provided completion for a unicode name with its relative symbol.
 With this, now IPython provides complete suggestions to unicode name symbols.
 
 As on the PR, if user types ``\LAT<tab>``, IPython provides a list of
 possible completions. In this case, it would be something like::
 
    'LATIN CAPITAL LETTER A',
    'LATIN CAPITAL LETTER B',
    'LATIN CAPITAL LETTER C',
    'LATIN CAPITAL LETTER D',
    ....
 
 This help to type unicode character that do not have short latex aliases, and
 have long unicode names. for example ``Ͱ``, ``\GREEK CAPITAL LETTER HETA``.
 
 This feature was contributed by Luciana Marques :ghpull:`11583`.
 
 Make audio normalization optional
 ---------------------------------
 
 Added 'normalize' argument to `IPython.display.Audio`. This argument applies
 when audio data is given as an array of samples. The default of `normalize=True`
 preserves prior behavior of normalizing the audio to the maximum possible range.
 Setting to `False` disables normalization.
 
 
 Miscellaneous
 -------------
 
  - Fix improper acceptation of ``return`` outside of functions. :ghpull:`11641`.
  - Fixed PyQt 5.11 backwards incompatibility causing sip import failure.
    :ghpull:`11613`.
  - Fix Bug where ``type?`` would crash IPython. :ghpull:`1608`.
  - Allow to apply ``@needs_local_scope`` to cell magics for convenience.
    :ghpull:`11542`.
 
 .. _whatsnew730:
 
 IPython 7.3.0
 =============
 
-.. _whatsnew720:
 
 IPython 7.3.0 bring several bug fixes and small improvements that you will
 described bellow. 
 
 The biggest change to this release is the implementation of the ``%conda`` and
 ``%pip`` magics, that will attempt to install packages in the **current
 environment**. You may still need to restart your interpreter or kernel for the
 change to be taken into account, but it should simplify installation of packages
 into remote environment. Installing using pip/conda from the command line is
 still the prefer method.
 
 The ``%pip`` magic was already present, but was only printing a warning; now it
 will actually forward commands to pip. 
 
 Misc bug fixes and improvements:
 
  - Compatibility with Python 3.8.
  - Do not expand shell variable in execution magics, and added the
    ``no_var_expand`` decorator for magic requiring a similar functionality
    :ghpull:`11516`
  - Add ``%pip`` and ``%conda`` magic :ghpull:`11524`
  - Re-initialize posix aliases after a ``%reset`` :ghpull:`11528`
  - Allow the IPython command line to run ``*.ipynb`` files :ghpull:`11529`
 
+.. _whatsnew720:
+   
 IPython 7.2.0
 =============
 
 IPython 7.2.0 brings minor bugfixes, improvements, and new configuration options:
 
  - Fix a bug preventing PySide2 GUI integration from working :ghpull:`11464`
  - Run CI on Mac OS ! :ghpull:`11471`
  - Fix IPython "Demo" mode. :ghpull:`11498`
  - Fix ``%run`` magic  with path in name :ghpull:`11499`
  - Fix: add CWD to sys.path *after* stdlib :ghpull:`11502`
  - Better rendering of signatures, especially long ones. :ghpull:`11505`
  - Re-enable jedi by default if it's installed :ghpull:`11506`
  - Add New ``minimal`` exception reporting mode (useful for educational purpose). See :ghpull:`11509`
 
 
 Added ability to show subclasses when using pinfo and other utilities
 ---------------------------------------------------------------------
 
 When using ``?``/``??`` on a class, IPython will now list the first 10 subclasses.
 
 Special Thanks to Chris Mentzel of the Moore Foundation for this feature. Chris
 is one of the people who played a critical role in IPython/Jupyter getting
 funding.
 
 We are grateful for all the help Chris has given us over the years,
 and we're now proud to have code contributed by Chris in IPython.
 
 OSMagics.cd_force_quiet configuration option
 --------------------------------------------
 
-You can set this option to force the %cd magic to behave as if ``-q`` was passed:
-::
+You can set this option to force the %cd magic to behave as if ``-q`` was passed::
 
     In [1]: cd /
     /
 
     In [2]: %config OSMagics.cd_force_quiet = True
 
     In [3]: cd /tmp
 
     In [4]:
 
 See :ghpull:`11491`
 
 In vi editing mode, whether the prompt includes the current vi mode can now be configured
 -----------------------------------------------------------------------------------------
 
 Set the ``TerminalInteractiveShell.prompt_includes_vi_mode`` to a boolean value
 (default: True) to control this feature. See :ghpull:`11492`
 
 .. _whatsnew710:
 
 IPython 7.1.0
 =============
 
 IPython 7.1.0 is the first minor release after 7.0.0 and mostly brings fixes to
 new features, internal refactoring, and fixes for regressions that happened during the 6.x->7.x
 transition. It also brings **Compatibility with Python 3.7.1**, as we're
 unwillingly relying on a bug in CPython.
 
 New Core Dev:
 
  - We welcome Jonathan Slenders to the commiters. Jonathan has done a fantastic
    work on prompt_toolkit, and we'd like to recognise his impact by giving him
    commit rights. :ghissue:`11397`
 
 Notable Changes
 
  - Major update of "latex to unicode" tab completion map (see below)
 
 Notable New Features:
 
  - Restore functionality and documentation of the **sphinx directive**, which
    is now stricter (fail on error by daefault), has new configuration options,
    has a brand new documentation page :ref:`ipython_directive` (which needs
    some cleanup). It is also now *tested* so we hope to have less regressions.
    :ghpull:`11402`
 
  - ``IPython.display.Video`` now supports ``width`` and ``height`` arguments,
    allowing a custom width and height to be set instead of using the video's
    width and height. :ghpull:`11353`
 
  - Warn when using ``HTML('<iframe>')`` instead of ``IFrame`` :ghpull:`11350`
 
  - Allow Dynamic switching of editing mode between vi/emacs and show
    normal/input mode in prompt when using vi. :ghpull:`11390`. Use ``%config
    TerminalInteractiveShell.editing_mode = 'vi'`` or ``%config
    TerminalInteractiveShell.editing_mode = 'emacs'`` to dynamically switch
    between modes.
 
 
 Notable Fixes:
 
  - Fix entering of **multi-line blocks in terminal** IPython, and various
    crashes in the new input transformation machinery :ghpull:`11354`,
    :ghpull:`11356`, :ghpull:`11358`. These also fix a **Compatibility bug
    with Python 3.7.1**.
 
  - Fix moving through generator stack in ipdb :ghpull:`11266`
 
  - %Magic command arguments now support quoting. :ghpull:`11330`
 
  - Re-add ``rprint`` and ``rprinte`` aliases. :ghpull:`11331`
 
  - Remove implicit dependency on ``ipython_genutils`` :ghpull:`11317`
 
  - Make ``nonlocal`` raise ``SyntaxError`` instead of silently failing in async
    mode. :ghpull:`11382`
 
  - Fix mishandling of magics and ``= !`` assignment just after a dedent in
    nested code blocks :ghpull:`11418`
 
  - Fix instructions for custom shortcuts :ghpull:`11426`
 
 
 Notable Internals improvements:
 
  - Use of ``os.scandir`` (Python 3 only) to speed up some file system operations.
    :ghpull:`11365`
 
  - use ``perf_counter`` instead of ``clock`` for more precise
    timing results with ``%time`` :ghpull:`11376`
 
 Many thanks to all the contributors and in particular to ``bartskowron`` and
 ``tonyfast`` who handled some pretty complicated bugs in the input machinery. We
 had a number of first time contributors and maybe hacktoberfest participants that
 made significant contributions and helped us free some time to focus on more
 complicated bugs.
 
 You
 can see all the closed issues and Merged PR, new features and fixes `here
 <https://github.com/ipython/ipython/issues?utf8=%E2%9C%93&q=+is%3Aclosed+milestone%3A7.1+>`_.
 
 Unicode Completion update
 -------------------------
 
 In IPython 7.1 the Unicode completion map has been updated and synchronized with
 the Julia language.
 
 Added and removed character characters:
 
  ``\jmath`` (``ȷ``), ``\\underleftrightarrow`` (U+034D, combining) have been
  added, while ``\\textasciicaron`` have been removed
 
 Some sequences have seen their prefix removed:
 
  - 6 characters ``\text...<tab>`` should now be inputed with ``\...<tab>`` directly,
  - 45 characters ``\Elz...<tab>`` should now be inputed with ``\...<tab>`` directly,
  - 65 characters ``\B...<tab>`` should now be inputed with ``\...<tab>`` directly,
  - 450 characters ``\m...<tab>`` should now be inputed with ``\...<tab>`` directly,
 
 Some sequences have seen their prefix shortened:
 
  - 5 characters ``\mitBbb...<tab>`` should now be inputed with ``\bbi...<tab>`` directly,
  - 52 characters ``\mit...<tab>`` should now be inputed with ``\i...<tab>`` directly,
  - 216 characters ``\mbfit...<tab>`` should now be inputed with ``\bi...<tab>`` directly,
  - 222 characters ``\mbf...<tab>`` should now be inputed with ``\b...<tab>`` directly,
 
 A couple of characters had their sequence simplified:
 
  - ``ð``, type ``\dh<tab>``, instead of ``\eth<tab>``
  - ``ħ``, type ``\hbar<tab>``, instead of ``\Elzxh<tab>``
  - ``ɸ``, type ``\ltphi<tab>``, instead of ``\textphi<tab>``
  - ``ϴ``, type ``\varTheta<tab>``, instead of ``\textTheta<tab>``
  - ``ℇ``, type ``\eulermascheroni<tab>``, instead of ``\Eulerconst<tab>``
  - ``ℎ``, type ``\planck<tab>``, instead of ``\Planckconst<tab>``
 
  - U+0336 (COMBINING LONG STROKE OVERLAY), type ``\strike<tab>``, instead of ``\Elzbar<tab>``.
 
 A couple of sequences have been updated:
 
  - ``\varepsilon`` now gives ``ɛ`` (GREEK SMALL LETTER EPSILON) instead of ``ε`` (GREEK LUNATE EPSILON SYMBOL),
  - ``\underbar`` now gives U+0331 (COMBINING MACRON BELOW) instead of U+0332 (COMBINING LOW LINE).
 
 
 .. _whatsnew700:
 
 IPython 7.0.0
 =============
 
 Released Thursday September 27th, 2018
 
 IPython 7 includes major feature improvements.
 This is also the second major version of IPython to support only
 Python 3 – starting at Python 3.4. Python 2 is still community-supported
 on the bugfix only 5.x branch, but we remind you that Python 2 "end of life"
 is on Jan 1st 2020.
 
 We were able to backport bug fixes to the 5.x branch thanks to our backport bot which
 backported more than `70 Pull-Requests
 <https://github.com/ipython/ipython/pulls?page=3&q=is%3Apr+sort%3Aupdated-desc+author%3Aapp%2Fmeeseeksdev++5.x&utf8=%E2%9C%93>`_, but there are still many PRs that required manual work. This is an area of the project where you can easily contribute by looking for `PRs that still need manual backport <https://github.com/ipython/ipython/issues?q=label%3A%22Still+Needs+Manual+Backport%22+is%3Aclosed+sort%3Aupdated-desc>`_
 
 The IPython 6.x branch will likely not see any further release unless critical
 bugs are found.
 
 Make sure you have pip > 9.0 before upgrading. You should be able to update by running:
 
 .. code::
 
     pip install ipython --upgrade
 
 .. only:: ipydev
 
   If you are trying to install or update an ``alpha``, ``beta``, or ``rc``
   version, use pip ``--pre`` flag.
 
   .. code::
 
       pip install ipython --upgrade --pre
 
 
 Or, if you have conda installed: 
 
 .. code::
    
    conda install ipython
 
 
 
 Prompt Toolkit 2.0
 ------------------
 
 IPython 7.0+ now uses ``prompt_toolkit 2.0``. If you still need to use an earlier
 ``prompt_toolkit`` version, you may need to pin IPython to ``<7.0``.
 
 Autowait: Asynchronous REPL
 ---------------------------
 
 Staring with IPython 7.0 on Python 3.6+, IPython can automatically ``await``
 top level code. You should not need to access an event loop or runner
 yourself. To learn 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 require further updates to the IPykernel package.
 
 Non-Asynchronous code
 ~~~~~~~~~~~~~~~~~~~~~
 
 As the internal API of IPython is now asynchronous, IPython needs to run under
 an event loop. In order to allow many workflows, (like using the :magic:`%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 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 an event loop is specified.
 
 Effects on Magics
 ~~~~~~~~~~~~~~~~~
 
 Some magics will not work with async until they're updated.
 Contributions welcome.
 
 Expected Future changes
 ~~~~~~~~~~~~~~~~~~~~~~~
 
 We expect more internal but public IPython functions to become ``async``, and
 will likely end up having a persistent event loop while IPython is running.
 
 Thanks
 ~~~~~~
 
 This release took more than a year in the making.
 The code was rebased a number of
 times; 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-cases: dalejung, danielballan, ellisonbg, fperez, gnestor,
 minrk, njsmith, pganssle, tacaswell, takluyver , vidartf ... And many others.
 
 
 Autoreload Improvement
 ----------------------
 
 The magic :magic:`%autoreload 2 <autoreload>` now captures new methods added to
 classes. Earlier, only methods existing as of the initial import were being
 tracked and updated.  
 
 This new feature helps dual environment development - Jupyter+IDE - where the
 code gradually moves from notebook cells to package files as it gets
 structured.
 
 **Example**: An instance of the class ``MyClass`` will be able to access the
 method ``cube()`` after it is uncommented and the file ``file1.py`` is saved on
 disk.
 
 
 .. code::
 
    # notebook
 
    from mymodule import MyClass
    first = MyClass(5)
 
 .. code::
 
    # mymodule/file1.py
 
    class MyClass:
 
        def __init__(self, a=10):
            self.a = a
 
        def square(self):
            print('compute square')
            return self.a*self.a
 
        # def cube(self):
        #     print('compute cube')
        #     return self.a*self.a*self.a
 
 
 
 
 Misc
 ----
 
 The autoindent feature that was deprecated in 5.x was re-enabled and
 un-deprecated in :ghpull:`11257`
 
 Make :magic:`%run -n -i ... <run>` work correctly. Earlier, if :magic:`%run` was
 passed both arguments, ``-n`` would be silently ignored. See :ghpull:`10308`
 
 
 The :cellmagic:`%%script` (as well as :cellmagic:`%%bash`,
 :cellmagic:`%%ruby`... ) cell magics now raise by default if the return code of
 the given code is non-zero (thus halting execution of further cells in a
 notebook). The behavior can be disable by passing the ``--no-raise-error`` flag.
 
 
 Deprecations
 ------------
 
 A couple of unused functions and methods have been deprecated and will be removed
 in future versions:
 
   - ``IPython.utils.io.raw_print_err``
   - ``IPython.utils.io.raw_print``
 
   
 Backwards incompatible changes
 ------------------------------
 
 * The API for transforming input before it is parsed as Python code has been
   completely redesigned: any custom input transformations will need to be
   rewritten. See :doc:`/config/inputtransforms` for details of the new API.