Merge branch 'master' into Carreau-patch-4

IPython/__init__.py

@@ -1,155 +1,156 b''
 """
 IPython: tools for interactive and parallel computing in Python.
 
 https://ipython.org
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2008-2011, IPython Development Team.
 #  Copyright (c) 2001-2007, Fernando Perez <[e-mail]>
 #  Copyright (c) 2001, Janko Hauser <[e-mail]>
 #  Copyright (c) 2001, Nathaniel Gray <[e-mail]>
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import sys
 
 #-----------------------------------------------------------------------------
 # Setup everything
 #-----------------------------------------------------------------------------
 
 # Don't forget to also update setup.py when this changes!
 if sys.version_info < (3, 8):
     raise ImportError(
 """
 IPython 8+ supports Python 3.8 and above, following NEP 29.
 When using Python 2.7, please install IPython 5.x LTS Long Term Support version.
 Python 3.3 and 3.4 were supported up to IPython 6.x.
 Python 3.5 was supported with IPython 7.0 to 7.9.
 Python 3.6 was supported with IPython up to 7.16.
 Python 3.7 was still supported with the 7.x branch.
 
 See IPython `README.rst` file for more information:
 
     https://github.com/ipython/ipython/blob/master/README.rst
 
-""")
+"""
+    )
 
 #-----------------------------------------------------------------------------
 # Setup the top level names
 #-----------------------------------------------------------------------------
 
 from .core.getipython import get_ipython
 from .core import release
 from .core.application import Application
 from .terminal.embed import embed
 
 from .core.interactiveshell import InteractiveShell
 from .utils.sysinfo import sys_info
 from .utils.frame import extract_module_locals
 
 # Release data
 __author__ = '%s <%s>' % (release.author, release.author_email)
 __license__  = release.license
 __version__  = release.version
 version_info = release.version_info
 # list of CVEs that should have been patched in this release.
 # this is informational and should not be relied upon.
 __patched_cves__ = {"CVE-2022-21699"}
 
 
 def embed_kernel(module=None, local_ns=None, **kwargs):
     """Embed and start an IPython kernel in a given scope.
 
     If you don't want the kernel to initialize the namespace
     from the scope of the surrounding function,
     and/or you want to load full IPython configuration,
     you probably want `IPython.start_kernel()` instead.
 
     Parameters
     ----------
     module : types.ModuleType, optional
         The module to load into IPython globals (default: caller)
     local_ns : dict, optional
         The namespace to load into IPython user namespace (default: caller)
     **kwargs : various, optional
         Further keyword args are relayed to the IPKernelApp constructor,
         allowing configuration of the Kernel.  Will only have an effect
         on the first embed_kernel call for a given process.
     """
     
     (caller_module, caller_locals) = extract_module_locals(1)
     if module is None:
         module = caller_module
     if local_ns is None:
         local_ns = caller_locals
     
     # Only import .zmq when we really need it
     from ipykernel.embed import embed_kernel as real_embed_kernel
     real_embed_kernel(module=module, local_ns=local_ns, **kwargs)
 
 def start_ipython(argv=None, **kwargs):
     """Launch a normal IPython instance (as opposed to embedded)
 
     `IPython.embed()` puts a shell in a particular calling scope,
     such as a function or method for debugging purposes,
     which is often not desirable.
 
     `start_ipython()` does full, regular IPython initialization,
     including loading startup files, configuration, etc.
     much of which is skipped by `embed()`.
 
     This is a public API method, and will survive implementation changes.
 
     Parameters
     ----------
     argv : list or None, optional
         If unspecified or None, IPython will parse command-line options from sys.argv.
         To prevent any command-line parsing, pass an empty list: `argv=[]`.
     user_ns : dict, optional
         specify this dictionary to initialize the IPython user namespace with particular values.
     **kwargs : various, optional
         Any other kwargs will be passed to the Application constructor,
         such as `config`.
     """
     from IPython.terminal.ipapp import launch_new_instance
     return launch_new_instance(argv=argv, **kwargs)
 
 def start_kernel(argv=None, **kwargs):
     """Launch a normal IPython kernel instance (as opposed to embedded)
 
     `IPython.embed_kernel()` puts a shell in a particular calling scope,
     such as a function or method for debugging purposes,
     which is often not desirable.
 
     `start_kernel()` does full, regular IPython initialization,
     including loading startup files, configuration, etc.
     much of which is skipped by `embed()`.
 
     Parameters
     ----------
     argv : list or None, optional
         If unspecified or None, IPython will parse command-line options from sys.argv.
         To prevent any command-line parsing, pass an empty list: `argv=[]`.
     user_ns : dict, optional
         specify this dictionary to initialize the IPython user namespace with particular values.
     **kwargs : various, optional
         Any other kwargs will be passed to the Application constructor,
         such as `config`.
     """
     import warnings
 
     warnings.warn(
         "start_kernel is deprecated since IPython 8.0, use from `ipykernel.kernelapp.launch_new_instance`",
         DeprecationWarning,
         stacklevel=2,
     )
     from ipykernel.kernelapp import launch_new_instance
     return launch_new_instance(argv=argv, **kwargs)

IPython/core/completer.py

@@ -1,2272 +1,2272 b''
 """Completion for IPython.
 
 This module started as fork of the rlcompleter module in the Python standard
 library.  The original enhancements made to rlcompleter have been sent
 upstream and were accepted as of Python 2.3,
 
 This module now support a wide variety of completion mechanism both available
 for normal classic Python code, as well as completer for IPython specific
 Syntax like magics.
 
 Latex and Unicode completion
 ============================
 
 IPython and compatible frontends not only can complete your code, but can help
 you to input a wide range of characters. In particular we allow you to insert
 a unicode character using the tab completion mechanism.
 
 Forward latex/unicode completion
 --------------------------------
 
 Forward completion allows you to easily type a unicode character using its latex
 name, or unicode long description. To do so type a backslash follow by the
 relevant name and press tab:
 
 
 Using latex completion:
 
 .. code::
 
     \\alpha<tab>
     α
 
 or using unicode completion:
 
 
 .. code::
 
     \\GREEK SMALL LETTER ALPHA<tab>
     α
 
 
 Only valid Python identifiers will complete. Combining characters (like arrow or
 dots) are also available, unlike latex they need to be put after the their
 counterpart that is to say, ``F\\\\vec<tab>`` is correct, not ``\\\\vec<tab>F``.
 
 Some browsers are known to display combining characters incorrectly.
 
 Backward latex completion
 -------------------------
 
 It is sometime challenging to know how to type a character, if you are using
 IPython, or any compatible frontend you can prepend backslash to the character
 and press ``<tab>`` to expand it to its latex form.
 
 .. code::
 
     \\α<tab>
     \\alpha
 
 
 Both forward and backward completions can be deactivated by setting the
 ``Completer.backslash_combining_completions`` option to ``False``.
 
 
 Experimental
 ============
 
 Starting with IPython 6.0, this module can make use of the Jedi library to
 generate completions both using static analysis of the code, and dynamically
 inspecting multiple namespaces. Jedi is an autocompletion and static analysis
 for Python. The APIs attached to this new mechanism is unstable and will
 raise unless use in an :any:`provisionalcompleter` context manager.
 
 You will find that the following are experimental:
 
     - :any:`provisionalcompleter`
     - :any:`IPCompleter.completions`
     - :any:`Completion`
     - :any:`rectify_completions`
 
 .. note::
 
     better name for :any:`rectify_completions` ?
 
 We welcome any feedback on these new API, and we also encourage you to try this
 module in debug mode (start IPython with ``--Completer.debug=True``) in order
 to have extra logging information if :any:`jedi` is crashing, or if current
 IPython completer pending deprecations are returning results not yet handled
 by :any:`jedi`
 
 Using Jedi for tab completion allow snippets like the following to work without
 having to execute any code:
 
    >>> myvar = ['hello', 42]
    ... myvar[1].bi<tab>
 
 Tab completion will be able to infer that ``myvar[1]`` is a real number without
 executing any code unlike the previously available ``IPCompleter.greedy``
 option.
 
 Be sure to update :any:`jedi` to the latest stable version or to try the
 current development version to get better completions.
 """
 
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 #
 # Some of this code originated from rlcompleter in the Python standard library
 # Copyright (C) 2001 Python Software Foundation, www.python.org
 
 
 import builtins as builtin_mod
 import glob
 import inspect
 import itertools
 import keyword
 import os
 import re
 import string
 import sys
 import time
 import unicodedata
 import uuid
 import warnings
 from contextlib import contextmanager
 from importlib import import_module
 from types import SimpleNamespace
 from typing import Iterable, Iterator, List, Tuple, Union, Any, Sequence, Dict, NamedTuple, Pattern, Optional
 
 from IPython.core.error import TryNext
 from IPython.core.inputtransformer2 import ESC_MAGIC
 from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
 from IPython.core.oinspect import InspectColors
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import generics
 from IPython.utils.dir2 import dir2, get_real_method
 from IPython.utils.path import ensure_dir_exists
 from IPython.utils.process import arg_split
 from traitlets import Bool, Enum, Int, List as ListTrait, Unicode, default, observe
 from traitlets.config.configurable import Configurable
 
 import __main__
 
 # skip module docstests
 __skip_doctest__ = True
 
 try:
     import jedi
     jedi.settings.case_insensitive_completion = False
     import jedi.api.helpers
     import jedi.api.classes
     JEDI_INSTALLED = True
 except ImportError:
     JEDI_INSTALLED = False
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 # ranges where we have most of the valid unicode names. We could be more finer
 # grained but is it worth it for performance  While unicode have character in the
 # range 0, 0x110000, we seem to have name for about 10% of those. (131808 as I
 # write this). With below range we cover them all, with a density of ~67%
 # biggest next gap we consider only adds up about 1% density and there are 600
 # gaps that would need hard coding.
 _UNICODE_RANGES = [(32, 0x3134b), (0xe0001, 0xe01f0)]
 
 # Public API
 __all__ = ['Completer','IPCompleter']
 
 if sys.platform == 'win32':
     PROTECTABLES = ' '
 else:
     PROTECTABLES = ' ()[]{}?=\\|;:\'#*"^&'
 
 # Protect against returning an enormous number of completions which the frontend
 # may have trouble processing.
 MATCHES_LIMIT = 500
 
 
 class ProvisionalCompleterWarning(FutureWarning):
     """
     Exception raise by an experimental feature in this module.
 
     Wrap code in :any:`provisionalcompleter` context manager if you
     are certain you want to use an unstable feature.
     """
     pass
 
 warnings.filterwarnings('error', category=ProvisionalCompleterWarning)
 
 
 @skip_doctest
 @contextmanager
 def provisionalcompleter(action='ignore'):
     """
     This context manager has to be used in any place where unstable completer
     behavior and API may be called.
 
     >>> with provisionalcompleter():
     ...     completer.do_experimental_things() # works
 
     >>> completer.do_experimental_things() # raises.
 
     .. note::
 
         Unstable
 
         By using this context manager you agree that the API in use may change
         without warning, and that you won't complain if they do so.
 
         You also understand that, if the API is not to your liking, you should report
         a bug to explain your use case upstream.
 
         We'll be happy to get your feedback, feature requests, and improvements on
         any of the unstable APIs!
     """
     with warnings.catch_warnings():
         warnings.filterwarnings(action, category=ProvisionalCompleterWarning)
         yield
 
 
 def has_open_quotes(s):
     """Return whether a string has open quotes.
 
     This simply counts whether the number of quote characters of either type in
     the string is odd.
 
     Returns
     -------
     If there is an open quote, the quote character is returned.  Else, return
     False.
     """
     # We check " first, then ', so complex cases with nested quotes will get
     # the " to take precedence.
     if s.count('"') % 2:
         return '"'
     elif s.count("'") % 2:
         return "'"
     else:
         return False
 
 
 def protect_filename(s, protectables=PROTECTABLES):
     """Escape a string to protect certain characters."""
     if set(s) & set(protectables):
         if sys.platform == "win32":
             return '"' + s + '"'
         else:
             return "".join(("\\" + c if c in protectables else c) for c in s)
     else:
         return s
 
 
 def expand_user(path:str) -> Tuple[str, bool, str]:
     """Expand ``~``-style usernames in strings.
 
     This is similar to :func:`os.path.expanduser`, but it computes and returns
     extra information that will be useful if the input was being used in
     computing completions, and you wish to return the completions with the
     original '~' instead of its expanded value.
 
     Parameters
     ----------
     path : str
         String to be expanded.  If no ~ is present, the output is the same as the
         input.
 
     Returns
     -------
     newpath : str
         Result of ~ expansion in the input path.
     tilde_expand : bool
         Whether any expansion was performed or not.
     tilde_val : str
         The value that ~ was replaced with.
     """
     # Default values
     tilde_expand = False
     tilde_val = ''
     newpath = path
 
     if path.startswith('~'):
         tilde_expand = True
         rest = len(path)-1
         newpath = os.path.expanduser(path)
         if rest:
             tilde_val = newpath[:-rest]
         else:
             tilde_val = newpath
 
     return newpath, tilde_expand, tilde_val
 
 
 def compress_user(path:str, tilde_expand:bool, tilde_val:str) -> str:
     """Does the opposite of expand_user, with its outputs.
     """
     if tilde_expand:
         return path.replace(tilde_val, '~')
     else:
         return path
 
 
 def completions_sorting_key(word):
     """key for sorting completions
 
     This does several things:
 
     - Demote any completions starting with underscores to the end
     - Insert any %magic and %%cellmagic completions in the alphabetical order
       by their name
     """
     prio1, prio2 = 0, 0
 
     if word.startswith('__'):
         prio1 = 2
     elif word.startswith('_'):
         prio1 = 1
 
     if word.endswith('='):
         prio1 = -1
 
     if word.startswith('%%'):
         # If there's another % in there, this is something else, so leave it alone
         if not "%" in word[2:]:
             word = word[2:]
             prio2 = 2
     elif word.startswith('%'):
         if not "%" in word[1:]:
             word = word[1:]
             prio2 = 1
 
     return prio1, word, prio2
 
 
 class _FakeJediCompletion:
     """
     This is a workaround to communicate to the UI that Jedi has crashed and to
     report a bug. Will be used only id :any:`IPCompleter.debug` is set to true.
 
     Added in IPython 6.0 so should likely be removed for 7.0
 
     """
 
     def __init__(self, name):
 
         self.name = name
         self.complete = name
         self.type = 'crashed'
         self.name_with_symbols = name
         self.signature = ''
         self._origin = 'fake'
 
     def __repr__(self):
         return '<Fake completion object jedi has crashed>'
 
 
 class Completion:
     """
     Completion object used and return by IPython completers.
 
     .. warning::
 
         Unstable
 
         This function is unstable, API may change without warning.
         It will also raise unless use in proper context manager.
 
     This act as a middle ground :any:`Completion` object between the
     :any:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
     object. While Jedi need a lot of information about evaluator and how the
     code should be ran/inspected, PromptToolkit (and other frontend) mostly
     need user facing information.
 
     - Which range should be replaced replaced by what.
     - Some metadata (like completion type), or meta information to displayed to
       the use user.
 
     For debugging purpose we can also store the origin of the completion (``jedi``,
     ``IPython.python_matches``, ``IPython.magics_matches``...).
     """
 
     __slots__ = ['start', 'end', 'text', 'type', 'signature', '_origin']
 
     def __init__(self, start: int, end: int, text: str, *, type: str=None, _origin='', signature='') -> None:
         warnings.warn("``Completion`` is a provisional API (as of IPython 6.0). "
                       "It may change without warnings. "
                       "Use in corresponding context manager.",
                       category=ProvisionalCompleterWarning, stacklevel=2)
 
         self.start = start
         self.end = end
         self.text = text
         self.type = type
         self.signature = signature
         self._origin = _origin
 
     def __repr__(self):
         return '<Completion start=%s end=%s text=%r type=%r, signature=%r,>' % \
                 (self.start, self.end, self.text, self.type or '?', self.signature or '?')
 
     def __eq__(self, other)->Bool:
         """
         Equality and hash do not hash the type (as some completer may not be
         able to infer the type), but are use to (partially) de-duplicate
         completion.
 
         Completely de-duplicating completion is a bit tricker that just
         comparing as it depends on surrounding text, which Completions are not
         aware of.
         """
         return self.start == other.start and \
             self.end == other.end and \
             self.text == other.text
 
     def __hash__(self):
         return hash((self.start, self.end, self.text))
 
 
 _IC = Iterable[Completion]
 
 
 def _deduplicate_completions(text: str, completions: _IC)-> _IC:
     """
     Deduplicate a set of completions.
 
     .. warning::
 
         Unstable
 
         This function is unstable, API may change without warning.
 
     Parameters
     ----------
     text : str
         text that should be completed.
     completions : Iterator[Completion]
         iterator over the completions to deduplicate
 
     Yields
     ------
     `Completions` objects
     Completions coming from multiple sources, may be different but end up having
     the same effect when applied to ``text``. If this is the case, this will
     consider completions as equal and only emit the first encountered.
     Not folded in `completions()` yet for debugging purpose, and to detect when
     the IPython completer does return things that Jedi does not, but should be
     at some point.
     """
     completions = list(completions)
     if not completions:
         return
 
     new_start = min(c.start for c in completions)
     new_end = max(c.end for c in completions)
 
     seen = set()
     for c in completions:
         new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
         if new_text not in seen:
             yield c
             seen.add(new_text)
 
 
 def rectify_completions(text: str, completions: _IC, *, _debug: bool = False) -> _IC:
     """
     Rectify a set of completions to all have the same ``start`` and ``end``
 
     .. warning::
 
         Unstable
 
         This function is unstable, API may change without warning.
         It will also raise unless use in proper context manager.
 
     Parameters
     ----------
     text : str
         text that should be completed.
     completions : Iterator[Completion]
         iterator over the completions to rectify
     _debug : bool
         Log failed completion
 
     Notes
     -----
     :any:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
     the Jupyter Protocol requires them to behave like so. This will readjust
     the completion to have the same ``start`` and ``end`` by padding both
     extremities with surrounding text.
 
     During stabilisation should support a ``_debug`` option to log which
     completion are return by the IPython completer and not found in Jedi in
     order to make upstream bug report.
     """
     warnings.warn("`rectify_completions` is a provisional API (as of IPython 6.0). "
                  "It may change without warnings. "
                  "Use in corresponding context manager.",
                   category=ProvisionalCompleterWarning, stacklevel=2)
 
     completions = list(completions)
     if not completions:
         return
     starts = (c.start for c in completions)
     ends = (c.end for c in completions)
 
     new_start = min(starts)
     new_end = max(ends)
 
     seen_jedi = set()
     seen_python_matches = set()
     for c in completions:
         new_text = text[new_start:c.start] + c.text + text[c.end:new_end]
         if c._origin == 'jedi':
             seen_jedi.add(new_text)
         elif c._origin == 'IPCompleter.python_matches':
             seen_python_matches.add(new_text)
         yield Completion(new_start, new_end, new_text, type=c.type, _origin=c._origin, signature=c.signature)
     diff = seen_python_matches.difference(seen_jedi)
     if diff and _debug:
         print('IPython.python matches have extras:', diff)
 
 
 if sys.platform == 'win32':
     DELIMS = ' \t\n`!@#$^&*()=+[{]}|;\'",<>?'
 else:
     DELIMS = ' \t\n`!@#$^&*()=+[{]}\\|;:\'",<>?'
 
 GREEDY_DELIMS = ' =\r\n'
 
 
 class CompletionSplitter(object):
     """An object to split an input line in a manner similar to readline.
 
     By having our own implementation, we can expose readline-like completion in
     a uniform manner to all frontends.  This object only needs to be given the
     line of text to be split and the cursor position on said line, and it
     returns the 'word' to be completed on at the cursor after splitting the
     entire line.
 
     What characters are used as splitting delimiters can be controlled by
     setting the ``delims`` attribute (this is a property that internally
     automatically builds the necessary regular expression)"""
 
     # Private interface
 
     # A string of delimiter characters.  The default value makes sense for
     # IPython's most typical usage patterns.
     _delims = DELIMS
 
     # The expression (a normal string) to be compiled into a regular expression
     # for actual splitting.  We store it as an attribute mostly for ease of
     # debugging, since this type of code can be so tricky to debug.
     _delim_expr = None
 
     # The regular expression that does the actual splitting
     _delim_re = None
 
     def __init__(self, delims=None):
         delims = CompletionSplitter._delims if delims is None else delims
         self.delims = delims
 
     @property
     def delims(self):
         """Return the string of delimiter characters."""
         return self._delims
 
     @delims.setter
     def delims(self, delims):
         """Set the delimiters for line splitting."""
         expr = '[' + ''.join('\\'+ c for c in delims) + ']'
         self._delim_re = re.compile(expr)
         self._delims = delims
         self._delim_expr = expr
 
     def split_line(self, line, cursor_pos=None):
         """Split a line of text with a cursor at the given position.
         """
         l = line if cursor_pos is None else line[:cursor_pos]
         return self._delim_re.split(l)[-1]
 
 
 
 class Completer(Configurable):
 
     greedy = Bool(False,
         help="""Activate greedy completion
         PENDING DEPRECATION. this is now mostly taken care of with Jedi.
 
         This will enable completion on elements of lists, results of function calls, etc.,
         but can be unsafe because the code is actually evaluated on TAB.
-        """
+        """,
     ).tag(config=True)
 
     use_jedi = Bool(default_value=JEDI_INSTALLED,
                     help="Experimental: Use Jedi to generate autocompletions. "
                     "Default to True if jedi is installed.").tag(config=True)
 
     jedi_compute_type_timeout = Int(default_value=400,
         help="""Experimental: restrict time (in milliseconds) during which Jedi can compute types.
         Set to 0 to stop computing types. Non-zero value lower than 100ms may hurt
         performance by preventing jedi to build its cache.
         """).tag(config=True)
 
     debug = Bool(default_value=False,
                  help='Enable debug for the Completer. Mostly print extra '
                       'information for experimental jedi integration.')\
                       .tag(config=True)
 
     backslash_combining_completions = Bool(True,
         help="Enable unicode completions, e.g. \\alpha<tab> . "
              "Includes completion of latex commands, unicode names, and expanding "
              "unicode characters back to latex commands.").tag(config=True)
 
     def __init__(self, namespace=None, global_namespace=None, **kwargs):
         """Create a new completer for the command line.
 
         Completer(namespace=ns, global_namespace=ns2) -> completer instance.
 
         If unspecified, the default namespace where completions are performed
         is __main__ (technically, __main__.__dict__). Namespaces should be
         given as dictionaries.
 
         An optional second namespace can be given.  This allows the completer
         to handle cases where both the local and global scopes need to be
         distinguished.
         """
 
         # Don't bind to namespace quite yet, but flag whether the user wants a
         # specific namespace or to use __main__.__dict__. This will allow us
         # to bind to __main__.__dict__ at completion time, not now.
         if namespace is None:
             self.use_main_ns = True
         else:
             self.use_main_ns = False
             self.namespace = namespace
 
         # The global namespace, if given, can be bound directly
         if global_namespace is None:
             self.global_namespace = {}
         else:
             self.global_namespace = global_namespace
 
         self.custom_matchers = []
 
         super(Completer, self).__init__(**kwargs)
 
     def complete(self, text, state):
         """Return the next possible completion for 'text'.
 
         This is called successively with state == 0, 1, 2, ... until it
         returns None.  The completion should begin with 'text'.
 
         """
         if self.use_main_ns:
             self.namespace = __main__.__dict__
 
         if state == 0:
             if "." in text:
                 self.matches = self.attr_matches(text)
             else:
                 self.matches = self.global_matches(text)
         try:
             return self.matches[state]
         except IndexError:
             return None
 
     def global_matches(self, text):
         """Compute matches when text is a simple name.
 
         Return a list of all keywords, built-in functions and names currently
         defined in self.namespace or self.global_namespace that match.
 
         """
         matches = []
         match_append = matches.append
         n = len(text)
         for lst in [keyword.kwlist,
                     builtin_mod.__dict__.keys(),
                     self.namespace.keys(),
                     self.global_namespace.keys()]:
             for word in lst:
                 if word[:n] == text and word != "__builtins__":
                     match_append(word)
 
         snake_case_re = re.compile(r"[^_]+(_[^_]+)+?\Z")
         for lst in [self.namespace.keys(),
                     self.global_namespace.keys()]:
             shortened = {"_".join([sub[0] for sub in word.split('_')]) : word
                          for word in lst if snake_case_re.match(word)}
             for word in shortened.keys():
                 if word[:n] == text and word != "__builtins__":
                     match_append(shortened[word])
         return matches
 
     def attr_matches(self, text):
         """Compute matches when text contains a dot.
 
         Assuming the text is of the form NAME.NAME....[NAME], and is
         evaluatable in self.namespace or self.global_namespace, it will be
         evaluated and its attributes (as revealed by dir()) are used as
         possible completions.  (For class instances, class members are
         also considered.)
 
         WARNING: this can still invoke arbitrary C code, if an object
         with a __getattr__ hook is evaluated.
 
         """
 
         # Another option, seems to work great. Catches things like ''.<tab>
         m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
 
         if m:
             expr, attr = m.group(1, 3)
         elif self.greedy:
             m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
             if not m2:
                 return []
             expr, attr = m2.group(1,2)
         else:
             return []
 
         try:
             obj = eval(expr, self.namespace)
         except:
             try:
                 obj = eval(expr, self.global_namespace)
             except:
                 return []
 
         if self.limit_to__all__ and hasattr(obj, '__all__'):
             words = get__all__entries(obj)
         else:
             words = dir2(obj)
 
         try:
             words = generics.complete_object(obj, words)
         except TryNext:
             pass
         except AssertionError:
             raise
         except Exception:
             # Silence errors from completion function
             #raise # dbg
             pass
         # Build match list to return
         n = len(attr)
         return [u"%s.%s" % (expr, w) for w in words if w[:n] == attr ]
 
 
 def get__all__entries(obj):
     """returns the strings in the __all__ attribute"""
     try:
         words = getattr(obj, '__all__')
     except:
         return []
 
     return [w for w in words if isinstance(w, str)]
 
 
 def match_dict_keys(keys: List[Union[str, bytes, Tuple[Union[str, bytes]]]], prefix: str, delims: str,
                     extra_prefix: Optional[Tuple[str, bytes]]=None) -> Tuple[str, int, List[str]]:
     """Used by dict_key_matches, matching the prefix to a list of keys
 
     Parameters
     ----------
     keys
         list of keys in dictionary currently being completed.
     prefix
         Part of the text already typed by the user. E.g. `mydict[b'fo`
     delims
         String of delimiters to consider when finding the current key.
     extra_prefix : optional
         Part of the text already typed in multi-key index cases. E.g. for
         `mydict['foo', "bar", 'b`, this would be `('foo', 'bar')`.
 
     Returns
     -------
     A tuple of three elements: ``quote``, ``token_start``, ``matched``, with
     ``quote`` being the quote that need to be used to close current string.
     ``token_start`` the position where the replacement should start occurring,
     ``matches`` a list of replacement/completion
 
     """
     prefix_tuple = extra_prefix if extra_prefix else ()
     Nprefix = len(prefix_tuple)
     def filter_prefix_tuple(key):
         # Reject too short keys
         if len(key) <= Nprefix:
             return False
         # Reject keys with non str/bytes in it
         for k in key:
             if not isinstance(k, (str, bytes)):
                 return False
         # Reject keys that do not match the prefix
         for k, pt in zip(key, prefix_tuple):
             if k != pt:
                 return False
         # All checks passed!
         return True
 
     filtered_keys:List[Union[str,bytes]] = []
     def _add_to_filtered_keys(key):
         if isinstance(key, (str, bytes)):
             filtered_keys.append(key)
 
     for k in keys:
         if isinstance(k, tuple):
             if filter_prefix_tuple(k):
                 _add_to_filtered_keys(k[Nprefix])
         else:
             _add_to_filtered_keys(k)
 
     if not prefix:
         return '', 0, [repr(k) for k in filtered_keys]
     quote_match = re.search('["\']', prefix)
     assert quote_match is not None # silence mypy
     quote = quote_match.group()
     try:
         prefix_str = eval(prefix + quote, {})
     except Exception:
         return '', 0, []
 
     pattern = '[^' + ''.join('\\' + c for c in delims) + ']*$'
     token_match = re.search(pattern, prefix, re.UNICODE)
     assert token_match is not None # silence mypy
     token_start = token_match.start()
     token_prefix = token_match.group()
 
     matched:List[str] = []
     for key in filtered_keys:
         try:
             if not key.startswith(prefix_str):
                 continue
         except (AttributeError, TypeError, UnicodeError):
             # Python 3+ TypeError on b'a'.startswith('a') or vice-versa
             continue
 
         # reformat remainder of key to begin with prefix
         rem = key[len(prefix_str):]
         # force repr wrapped in '
         rem_repr = repr(rem + '"') if isinstance(rem, str) else repr(rem + b'"')
         rem_repr = rem_repr[1 + rem_repr.index("'"):-2]
         if quote == '"':
             # The entered prefix is quoted with ",
             # but the match is quoted with '.
             # A contained " hence needs escaping for comparison:
             rem_repr = rem_repr.replace('"', '\\"')
 
         # then reinsert prefix from start of token
         matched.append('%s%s' % (token_prefix, rem_repr))
     return quote, token_start, matched
 
 
 def cursor_to_position(text:str, line:int, column:int)->int:
     """
     Convert the (line,column) position of the cursor in text to an offset in a
     string.
 
     Parameters
     ----------
     text : str
         The text in which to calculate the cursor offset
     line : int
         Line of the cursor; 0-indexed
     column : int
         Column of the cursor 0-indexed
 
     Returns
     -------
     Position of the cursor in ``text``, 0-indexed.
 
     See Also
     --------
     position_to_cursor : reciprocal of this function
 
     """
     lines = text.split('\n')
     assert line <= len(lines), '{} <= {}'.format(str(line), str(len(lines)))
 
     return sum(len(l) + 1 for l in lines[:line]) + column
 
 def position_to_cursor(text:str, offset:int)->Tuple[int, int]:
     """
     Convert the position of the cursor in text (0 indexed) to a line
     number(0-indexed) and a column number (0-indexed) pair
 
     Position should be a valid position in ``text``.
 
     Parameters
     ----------
     text : str
         The text in which to calculate the cursor offset
     offset : int
         Position of the cursor in ``text``, 0-indexed.
 
     Returns
     -------
     (line, column) : (int, int)
         Line of the cursor; 0-indexed, column of the cursor 0-indexed
 
     See Also
     --------
     cursor_to_position : reciprocal of this function
 
     """
 
     assert 0 <= offset <= len(text) , "0 <= %s <= %s" % (offset , len(text))
 
     before = text[:offset]
     blines = before.split('\n')  # ! splitnes trim trailing \n
     line = before.count('\n')
     col = len(blines[-1])
     return line, col
 
 
 def _safe_isinstance(obj, module, class_name):
     """Checks if obj is an instance of module.class_name if loaded
     """
     return (module in sys.modules and
             isinstance(obj, getattr(import_module(module), class_name)))
 
 def back_unicode_name_matches(text:str) -> Tuple[str, Sequence[str]]:
     """Match Unicode characters back to Unicode name
 
     This does  ``☃`` -> ``\\snowman``
 
     Note that snowman is not a valid python3 combining character but will be expanded.
     Though it will not recombine back to the snowman character by the completion machinery.
 
     This will not either back-complete standard sequences like \\n, \\b ...
 
     Returns
     =======
 
     Return a tuple with two elements:
 
     - The Unicode character that was matched (preceded with a backslash), or
         empty string,
     - a sequence (of 1), name for the match Unicode character, preceded by
         backslash, or empty if no match.
     
     """
     if len(text)<2:
         return '', ()
     maybe_slash = text[-2]
     if maybe_slash != '\\':
         return '', ()
 
     char = text[-1]
     # no expand on quote for completion in strings.
     # nor backcomplete standard ascii keys
     if char in string.ascii_letters or char in ('"',"'"):
         return '', ()
     try :
         unic = unicodedata.name(char)
         return '\\'+char,('\\'+unic,)
     except KeyError:
         pass
     return '', ()
 
 def back_latex_name_matches(text:str) -> Tuple[str, Sequence[str]] :
     """Match latex characters back to unicode name
 
     This does ``\\ℵ`` -> ``\\aleph``
 
     """
     if len(text)<2:
         return '', ()
     maybe_slash = text[-2]
     if maybe_slash != '\\':
         return '', ()
 
 
     char = text[-1]
     # no expand on quote for completion in strings.
     # nor backcomplete standard ascii keys
     if char in string.ascii_letters or char in ('"',"'"):
         return '', ()
     try :
         latex = reverse_latex_symbol[char]
         # '\\' replace the \ as well
         return '\\'+char,[latex]
     except KeyError:
         pass
     return '', ()
 
 
 def _formatparamchildren(parameter) -> str:
     """
     Get parameter name and value from Jedi Private API
 
     Jedi does not expose a simple way to get `param=value` from its API.
 
     Parameters
     ----------
     parameter
         Jedi's function `Param`
 
     Returns
     -------
     A string like 'a', 'b=1', '*args', '**kwargs'
 
     """
     description = parameter.description
     if not description.startswith('param '):
         raise ValueError('Jedi function parameter description have change format.'
                          'Expected "param ...", found %r".' % description)
     return description[6:]
 
 def _make_signature(completion)-> str:
     """
     Make the signature from a jedi completion
 
     Parameters
     ----------
     completion : jedi.Completion
         object does not complete a function type
 
     Returns
     -------
     a string consisting of the function signature, with the parenthesis but
     without the function name. example:
     `(a, *args, b=1, **kwargs)`
 
     """
 
     # it looks like this might work on jedi 0.17
     if hasattr(completion, 'get_signatures'):
         signatures = completion.get_signatures()
         if not signatures:
             return  '(?)'
 
         c0 = completion.get_signatures()[0]
         return '('+c0.to_string().split('(', maxsplit=1)[1]
 
     return '(%s)'% ', '.join([f for f in (_formatparamchildren(p) for signature in completion.get_signatures()
                                           for p in signature.defined_names()) if f])
 
 
 class _CompleteResult(NamedTuple):
     matched_text : str
     matches: Sequence[str]
     matches_origin: Sequence[str]
     jedi_matches: Any
 
 
 class IPCompleter(Completer):
     """Extension of the completer class with IPython-specific features"""
 
     __dict_key_regexps: Optional[Dict[bool,Pattern]] = None
 
     @observe('greedy')
     def _greedy_changed(self, change):
         """update the splitter and readline delims when greedy is changed"""
         if change['new']:
             self.splitter.delims = GREEDY_DELIMS
         else:
             self.splitter.delims = DELIMS
 
     dict_keys_only = Bool(False,
         help="""Whether to show dict key matches only""")
 
     merge_completions = Bool(True,
         help="""Whether to merge completion results into a single list
 
         If False, only the completion results from the first non-empty
         completer will be returned.
         """
     ).tag(config=True)
     omit__names = Enum((0,1,2), default_value=2,
         help="""Instruct the completer to omit private method names
 
         Specifically, when completing on ``object.<tab>``.
 
         When 2 [default]: all names that start with '_' will be excluded.
 
         When 1: all 'magic' names (``__foo__``) will be excluded.
 
         When 0: nothing will be excluded.
         """
     ).tag(config=True)
     limit_to__all__ = Bool(False,
         help="""
         DEPRECATED as of version 5.0.
 
         Instruct the completer to use __all__ for the completion
 
         Specifically, when completing on ``object.<tab>``.
 
         When True: only those names in obj.__all__ will be included.
 
         When False [default]: the __all__ attribute is ignored
         """,
     ).tag(config=True)
 
     profile_completions = Bool(
         default_value=False,
         help="If True, emit profiling data for completion subsystem using cProfile."
     ).tag(config=True)
 
     profiler_output_dir = Unicode(
         default_value=".completion_profiles",
         help="Template for path at which to output profile data for completions."
     ).tag(config=True)
 
     @observe('limit_to__all__')
     def _limit_to_all_changed(self, change):
         warnings.warn('`IPython.core.IPCompleter.limit_to__all__` configuration '
             'value has been deprecated since IPython 5.0, will be made to have '
             'no effects and then removed in future version of IPython.',
             UserWarning)
 
     def __init__(
         self, shell=None, namespace=None, global_namespace=None, config=None, **kwargs
     ):
         """IPCompleter() -> completer
 
         Return a completer object.
 
         Parameters
         ----------
         shell
             a pointer to the ipython shell itself.  This is needed
             because this completer knows about magic functions, and those can
             only be accessed via the ipython instance.
         namespace : dict, optional
             an optional dict where completions are performed.
         global_namespace : dict, optional
             secondary optional dict for completions, to
             handle cases (such as IPython embedded inside functions) where
             both Python scopes are visible.
         config : Config
             traitlet's config object
         **kwargs
             passed to super class unmodified.
         """
 
         self.magic_escape = ESC_MAGIC
         self.splitter = CompletionSplitter()
 
         # _greedy_changed() depends on splitter and readline being defined:
         super().__init__(
             namespace=namespace,
             global_namespace=global_namespace,
             config=config,
             **kwargs
         )
 
         # List where completion matches will be stored
         self.matches = []
         self.shell = shell
         # Regexp to split filenames with spaces in them
         self.space_name_re = re.compile(r'([^\\] )')
         # Hold a local ref. to glob.glob for speed
         self.glob = glob.glob
 
         # Determine if we are running on 'dumb' terminals, like (X)Emacs
         # buffers, to avoid completion problems.
         term = os.environ.get('TERM','xterm')
         self.dumb_terminal = term in ['dumb','emacs']
 
         # Special handling of backslashes needed in win32 platforms
         if sys.platform == "win32":
             self.clean_glob = self._clean_glob_win32
         else:
             self.clean_glob = self._clean_glob
 
         #regexp to parse docstring for function signature
         self.docstring_sig_re = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
         self.docstring_kwd_re = re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
         #use this if positional argument name is also needed
         #= re.compile(r'[\s|\[]*(\w+)(?:\s*=?\s*.*)')
 
         self.magic_arg_matchers = [
             self.magic_config_matches,
             self.magic_color_matches,
         ]
 
         # This is set externally by InteractiveShell
         self.custom_completers = None
 
         # This is a list of names of unicode characters that can be completed
         # into their corresponding unicode value. The list is large, so we
         # lazily initialize it on first use. Consuming code should access this
         # attribute through the `@unicode_names` property.
         self._unicode_names = None
 
     @property
     def matchers(self) -> List[Any]:
         """All active matcher routines for completion"""
         if self.dict_keys_only:
             return [self.dict_key_matches]
 
         if self.use_jedi:
             return [
                 *self.custom_matchers,
                 self.dict_key_matches,
                 self.file_matches,
                 self.magic_matches,
             ]
         else:
             return [
                 *self.custom_matchers,
                 self.dict_key_matches,
                 self.python_matches,
                 self.file_matches,
                 self.magic_matches,
                 self.python_func_kw_matches,
             ]
 
     def all_completions(self, text:str) -> List[str]:
         """
         Wrapper around the completion methods for the benefit of emacs.
         """
         prefix = text.rpartition('.')[0]
         with provisionalcompleter():
             return ['.'.join([prefix, c.text]) if prefix and self.use_jedi else c.text
                     for c in self.completions(text, len(text))]
 
         return self.complete(text)[1]
 
     def _clean_glob(self, text:str):
         return self.glob("%s*" % text)
 
     def _clean_glob_win32(self, text:str):
         return [f.replace("\\","/")
                 for f in self.glob("%s*" % text)]
 
     def file_matches(self, text:str)->List[str]:
         """Match filenames, expanding ~USER type strings.
 
         Most of the seemingly convoluted logic in this completer is an
         attempt to handle filenames with spaces in them.  And yet it's not
         quite perfect, because Python's readline doesn't expose all of the
         GNU readline details needed for this to be done correctly.
 
         For a filename with a space in it, the printed completions will be
         only the parts after what's already been typed (instead of the
         full completions, as is normally done).  I don't think with the
         current (as of Python 2.3) Python readline it's possible to do
         better."""
 
         # chars that require escaping with backslash - i.e. chars
         # that readline treats incorrectly as delimiters, but we
         # don't want to treat as delimiters in filename matching
         # when escaped with backslash
         if text.startswith('!'):
             text = text[1:]
             text_prefix = u'!'
         else:
             text_prefix = u''
 
         text_until_cursor = self.text_until_cursor
         # track strings with open quotes
         open_quotes = has_open_quotes(text_until_cursor)
 
         if '(' in text_until_cursor or '[' in text_until_cursor:
             lsplit = text
         else:
             try:
                 # arg_split ~ shlex.split, but with unicode bugs fixed by us
                 lsplit = arg_split(text_until_cursor)[-1]
             except ValueError:
                 # typically an unmatched ", or backslash without escaped char.
                 if open_quotes:
                     lsplit = text_until_cursor.split(open_quotes)[-1]
                 else:
                     return []
             except IndexError:
                 # tab pressed on empty line
                 lsplit = ""
 
         if not open_quotes and lsplit != protect_filename(lsplit):
             # if protectables are found, do matching on the whole escaped name
             has_protectables = True
             text0,text = text,lsplit
         else:
             has_protectables = False
             text = os.path.expanduser(text)
 
         if text == "":
             return [text_prefix + protect_filename(f) for f in self.glob("*")]
 
         # Compute the matches from the filesystem
         if sys.platform == 'win32':
             m0 = self.clean_glob(text)
         else:
             m0 = self.clean_glob(text.replace('\\', ''))
 
         if has_protectables:
             # If we had protectables, we need to revert our changes to the
             # beginning of filename so that we don't double-write the part
             # of the filename we have so far
             len_lsplit = len(lsplit)
             matches = [text_prefix + text0 +
                        protect_filename(f[len_lsplit:]) for f in m0]
         else:
             if open_quotes:
                 # if we have a string with an open quote, we don't need to
                 # protect the names beyond the quote (and we _shouldn't_, as
                 # it would cause bugs when the filesystem call is made).
                 matches = m0 if sys.platform == "win32" else\
                     [protect_filename(f, open_quotes) for f in m0]
             else:
                 matches = [text_prefix +
                            protect_filename(f) for f in m0]
 
         # Mark directories in input list by appending '/' to their names.
         return [x+'/' if os.path.isdir(x) else x for x in matches]
 
     def magic_matches(self, text:str):
         """Match magics"""
         # Get all shell magics now rather than statically, so magics loaded at
         # runtime show up too.
         lsm = self.shell.magics_manager.lsmagic()
         line_magics = lsm['line']
         cell_magics = lsm['cell']
         pre = self.magic_escape
         pre2 = pre+pre
 
         explicit_magic = text.startswith(pre)
 
         # Completion logic:
         # - user gives %%: only do cell magics
         # - user gives %: do both line and cell magics
         # - no prefix: do both
         # In other words, line magics are skipped if the user gives %% explicitly
         #
         # We also exclude magics that match any currently visible names:
         # https://github.com/ipython/ipython/issues/4877, unless the user has
         # typed a %:
         # https://github.com/ipython/ipython/issues/10754
         bare_text = text.lstrip(pre)
         global_matches = self.global_matches(bare_text)
         if not explicit_magic:
             def matches(magic):
                 """
                 Filter magics, in particular remove magics that match
                 a name present in global namespace.
                 """
                 return ( magic.startswith(bare_text) and
                          magic not in global_matches )
         else:
             def matches(magic):
                 return magic.startswith(bare_text)
 
         comp = [ pre2+m for m in cell_magics if matches(m)]
         if not text.startswith(pre2):
             comp += [ pre+m for m in line_magics if matches(m)]
 
         return comp
 
     def magic_config_matches(self, text:str) -> List[str]:
         """ Match class names and attributes for %config magic """
         texts = text.strip().split()
 
         if len(texts) > 0 and (texts[0] == 'config' or texts[0] == '%config'):
             # get all configuration classes
             classes = sorted(set([ c for c in self.shell.configurables
                                    if c.__class__.class_traits(config=True)
                                    ]), key=lambda x: x.__class__.__name__)
             classnames = [ c.__class__.__name__ for c in classes ]
 
             # return all classnames if config or %config is given
             if len(texts) == 1:
                 return classnames
 
             # match classname
             classname_texts = texts[1].split('.')
             classname = classname_texts[0]
             classname_matches = [ c for c in classnames
                                   if c.startswith(classname) ]
 
             # return matched classes or the matched class with attributes
             if texts[1].find('.') < 0:
                 return classname_matches
             elif len(classname_matches) == 1 and \
                             classname_matches[0] == classname:
                 cls = classes[classnames.index(classname)].__class__
                 help = cls.class_get_help()
                 # strip leading '--' from cl-args:
                 help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
                 return [ attr.split('=')[0]
                          for attr in help.strip().splitlines()
                          if attr.startswith(texts[1]) ]
         return []
 
     def magic_color_matches(self, text:str) -> List[str] :
         """ Match color schemes for %colors magic"""
         texts = text.split()
         if text.endswith(' '):
             # .split() strips off the trailing whitespace. Add '' back
             # so that: '%colors ' -> ['%colors', '']
             texts.append('')
 
         if len(texts) == 2 and (texts[0] == 'colors' or texts[0] == '%colors'):
             prefix = texts[1]
             return [ color for color in InspectColors.keys()
                      if color.startswith(prefix) ]
         return []
 
     def _jedi_matches(self, cursor_column:int, cursor_line:int, text:str) -> Iterable[Any]:
         """
         Return a list of :any:`jedi.api.Completions` object from a ``text`` and
         cursor position.
 
         Parameters
         ----------
         cursor_column : int
             column position of the cursor in ``text``, 0-indexed.
         cursor_line : int
             line position of the cursor in ``text``, 0-indexed
         text : str
             text to complete
 
         Notes
         -----
         If ``IPCompleter.debug`` is ``True`` may return a :any:`_FakeJediCompletion`
         object containing a string with the Jedi debug information attached.
         """
         namespaces = [self.namespace]
         if self.global_namespace is not None:
             namespaces.append(self.global_namespace)
 
         completion_filter = lambda x:x
         offset = cursor_to_position(text, cursor_line, cursor_column)
         # filter output if we are completing for object members
         if offset:
             pre = text[offset-1]
             if pre == '.':
                 if self.omit__names == 2:
                     completion_filter = lambda c:not c.name.startswith('_')
                 elif self.omit__names == 1:
                     completion_filter = lambda c:not (c.name.startswith('__') and c.name.endswith('__'))
                 elif self.omit__names == 0:
                     completion_filter = lambda x:x
                 else:
                     raise ValueError("Don't understand self.omit__names == {}".format(self.omit__names))
 
         interpreter = jedi.Interpreter(text[:offset], namespaces)
         try_jedi = True
 
         try:
             # find the first token in the current tree -- if it is a ' or " then we are in a string
             completing_string = False
             try:
                 first_child = next(c for c in interpreter._get_module().tree_node.children if hasattr(c, 'value'))
             except StopIteration:
                 pass
             else:
                 # note the value may be ', ", or it may also be ''' or """, or
                 # in some cases, """what/you/typed..., but all of these are
                 # strings.
                 completing_string = len(first_child.value) > 0 and first_child.value[0] in {"'", '"'}
 
             # if we are in a string jedi is likely not the right candidate for
             # now. Skip it.
             try_jedi = not completing_string
         except Exception as e:
             # many of things can go wrong, we are using private API just don't crash.
             if self.debug:
                 print("Error detecting if completing a non-finished string :", e, '|')
 
         if not try_jedi:
             return []
         try:
             return filter(completion_filter, interpreter.complete(column=cursor_column, line=cursor_line + 1))
         except Exception as e:
             if self.debug:
                 return [_FakeJediCompletion('Oops Jedi has crashed, please report a bug with the following:\n"""\n%s\ns"""' % (e))]
             else:
                 return []
 
     def python_matches(self, text:str)->List[str]:
         """Match attributes or global python names"""
         if "." in text:
             try:
                 matches = self.attr_matches(text)
                 if text.endswith('.') and self.omit__names:
                     if self.omit__names == 1:
                         # true if txt is _not_ a __ name, false otherwise:
                         no__name = (lambda txt:
                                     re.match(r'.*\.__.*?__',txt) is None)
                     else:
                         # true if txt is _not_ a _ name, false otherwise:
                         no__name = (lambda txt:
                                     re.match(r'\._.*?',txt[txt.rindex('.'):]) is None)
                     matches = filter(no__name, matches)
             except NameError:
                 # catches <undefined attributes>.<tab>
                 matches = []
         else:
             matches = self.global_matches(text)
         return matches
 
     def _default_arguments_from_docstring(self, doc):
         """Parse the first line of docstring for call signature.
 
         Docstring should be of the form 'min(iterable[, key=func])\n'.
         It can also parse cython docstring of the form
         'Minuit.migrad(self, int ncall=10000, resume=True, int nsplit=1)'.
         """
         if doc is None:
             return []
 
         #care only the firstline
         line = doc.lstrip().splitlines()[0]
 
         #p = re.compile(r'^[\w|\s.]+\(([^)]*)\).*')
         #'min(iterable[, key=func])\n' -> 'iterable[, key=func]'
         sig = self.docstring_sig_re.search(line)
         if sig is None:
             return []
         # iterable[, key=func]' -> ['iterable[' ,' key=func]']
         sig = sig.groups()[0].split(',')
         ret = []
         for s in sig:
             #re.compile(r'[\s|\[]*(\w+)(?:\s*=\s*.*)')
             ret += self.docstring_kwd_re.findall(s)
         return ret
 
     def _default_arguments(self, obj):
         """Return the list of default arguments of obj if it is callable,
         or empty list otherwise."""
         call_obj = obj
         ret = []
         if inspect.isbuiltin(obj):
             pass
         elif not (inspect.isfunction(obj) or inspect.ismethod(obj)):
             if inspect.isclass(obj):
                 #for cython embedsignature=True the constructor docstring
                 #belongs to the object itself not __init__
                 ret += self._default_arguments_from_docstring(
                             getattr(obj, '__doc__', ''))
                 # for classes, check for __init__,__new__
                 call_obj = (getattr(obj, '__init__', None) or
                        getattr(obj, '__new__', None))
             # for all others, check if they are __call__able
             elif hasattr(obj, '__call__'):
                 call_obj = obj.__call__
         ret += self._default_arguments_from_docstring(
                  getattr(call_obj, '__doc__', ''))
 
         _keeps = (inspect.Parameter.KEYWORD_ONLY,
                   inspect.Parameter.POSITIONAL_OR_KEYWORD)
 
         try:
             sig = inspect.signature(obj)
             ret.extend(k for k, v in sig.parameters.items() if
                        v.kind in _keeps)
         except ValueError:
             pass
 
         return list(set(ret))
 
     def python_func_kw_matches(self, text):
         """Match named parameters (kwargs) of the last open function"""
 
         if "." in text: # a parameter cannot be dotted
             return []
         try: regexp = self.__funcParamsRegex
         except AttributeError:
             regexp = self.__funcParamsRegex = re.compile(r'''
                 '.*?(?<!\\)' |    # single quoted strings or
                 ".*?(?<!\\)" |    # double quoted strings or
                 \w+          |    # identifier
                 \S                # other characters
                 ''', re.VERBOSE | re.DOTALL)
         # 1. find the nearest identifier that comes before an unclosed
         # parenthesis before the cursor
         # e.g. for "foo (1+bar(x), pa<cursor>,a=1)", the candidate is "foo"
         tokens = regexp.findall(self.text_until_cursor)
         iterTokens = reversed(tokens); openPar = 0
 
         for token in iterTokens:
             if token == ')':
                 openPar -= 1
             elif token == '(':
                 openPar += 1
                 if openPar > 0:
                     # found the last unclosed parenthesis
                     break
         else:
             return []
         # 2. Concatenate dotted names ("foo.bar" for "foo.bar(x, pa" )
         ids = []
         isId = re.compile(r'\w+$').match
 
         while True:
             try:
                 ids.append(next(iterTokens))
                 if not isId(ids[-1]):
                     ids.pop(); break
                 if not next(iterTokens) == '.':
                     break
             except StopIteration:
                 break
 
         # Find all named arguments already assigned to, as to avoid suggesting
         # them again
         usedNamedArgs = set()
         par_level = -1
         for token, next_token in zip(tokens, tokens[1:]):
             if token == '(':
                 par_level += 1
             elif token == ')':
                 par_level -= 1
 
             if par_level != 0:
                 continue
 
             if next_token != '=':
                 continue
 
             usedNamedArgs.add(token)
 
         argMatches = []
         try:
             callableObj = '.'.join(ids[::-1])
             namedArgs = self._default_arguments(eval(callableObj,
                                                     self.namespace))
 
             # Remove used named arguments from the list, no need to show twice
             for namedArg in set(namedArgs) - usedNamedArgs:
                 if namedArg.startswith(text):
                     argMatches.append("%s=" %namedArg)
         except:
             pass
 
         return argMatches
 
     @staticmethod
     def _get_keys(obj: Any) -> List[Any]:
         # Objects can define their own completions by defining an
         # _ipy_key_completions_() method.
         method = get_real_method(obj, '_ipython_key_completions_')
         if method is not None:
             return method()
 
         # Special case some common in-memory dict-like types
         if isinstance(obj, dict) or\
            _safe_isinstance(obj, 'pandas', 'DataFrame'):
             try:
                 return list(obj.keys())
             except Exception:
                 return []
         elif _safe_isinstance(obj, 'numpy', 'ndarray') or\
              _safe_isinstance(obj, 'numpy', 'void'):
             return obj.dtype.names or []
         return []
 
     def dict_key_matches(self, text:str) -> List[str]:
         "Match string keys in a dictionary, after e.g. 'foo[' "
 
 
         if self.__dict_key_regexps is not None:
             regexps = self.__dict_key_regexps
         else:
             dict_key_re_fmt = r'''(?x)
             (  # match dict-referring expression wrt greedy setting
                 %s
             )
             \[   # open bracket
             \s*  # and optional whitespace
             # Capture any number of str-like objects (e.g. "a", "b", 'c')
             ((?:[uUbB]?  # string prefix (r not handled)
                 (?:
                     '(?:[^']|(?<!\\)\\')*'
                 |
                     "(?:[^"]|(?<!\\)\\")*"
                 )
                 \s*,\s*
             )*)
             ([uUbB]?  # string prefix (r not handled)
                 (?:   # unclosed string
                     '(?:[^']|(?<!\\)\\')*
                 |
                     "(?:[^"]|(?<!\\)\\")*
                 )
             )?
             $
             '''
             regexps = self.__dict_key_regexps = {
                 False: re.compile(dict_key_re_fmt % r'''
                                   # identifiers separated by .
                                   (?!\d)\w+
                                   (?:\.(?!\d)\w+)*
                                   '''),
                 True: re.compile(dict_key_re_fmt % '''
                                  .+
                                  ''')
             }
 
         match = regexps[self.greedy].search(self.text_until_cursor)
 
         if match is None:
             return []
 
         expr, prefix0, prefix = match.groups()
         try:
             obj = eval(expr, self.namespace)
         except Exception:
             try:
                 obj = eval(expr, self.global_namespace)
             except Exception:
                 return []
 
         keys = self._get_keys(obj)
         if not keys:
             return keys
 
         extra_prefix = eval(prefix0) if prefix0 != '' else None
 
         closing_quote, token_offset, matches = match_dict_keys(keys, prefix, self.splitter.delims, extra_prefix=extra_prefix)
         if not matches:
             return matches
 
         # get the cursor position of
         # - the text being completed
         # - the start of the key text
         # - the start of the completion
         text_start = len(self.text_until_cursor) - len(text)
         if prefix:
             key_start = match.start(3)
             completion_start = key_start + token_offset
         else:
             key_start = completion_start = match.end()
 
         # grab the leading prefix, to make sure all completions start with `text`
         if text_start > key_start:
             leading = ''
         else:
             leading = text[text_start:completion_start]
 
         # the index of the `[` character
         bracket_idx = match.end(1)
 
         # append closing quote and bracket as appropriate
         # this is *not* appropriate if the opening quote or bracket is outside
         # the text given to this method
         suf = ''
         continuation = self.line_buffer[len(self.text_until_cursor):]
         if key_start > text_start and closing_quote:
             # quotes were opened inside text, maybe close them
             if continuation.startswith(closing_quote):
                 continuation = continuation[len(closing_quote):]
             else:
                 suf += closing_quote
         if bracket_idx > text_start:
             # brackets were opened inside text, maybe close them
             if not continuation.startswith(']'):
                 suf += ']'
 
         return [leading + k + suf for k in matches]
 
     @staticmethod
     def unicode_name_matches(text:str) -> Tuple[str, List[str]] :
         """Match Latex-like syntax for unicode characters base
         on the name of the character.
 
         This does  ``\\GREEK SMALL LETTER ETA`` -> ``η``
 
         Works only on valid python 3 identifier, or on combining characters that
         will combine to form a valid identifier.
         """
         slashpos = text.rfind('\\')
         if slashpos > -1:
             s = text[slashpos+1:]
             try :
                 unic = unicodedata.lookup(s)
                 # allow combining chars
                 if ('a'+unic).isidentifier():
                     return '\\'+s,[unic]
             except KeyError:
                 pass
         return '', []
 
 
     def latex_matches(self, text:str) -> Tuple[str, Sequence[str]]:
         """Match Latex syntax for unicode characters.
 
         This does both ``\\alp`` -> ``\\alpha`` and ``\\alpha`` -> ``α``
         """
         slashpos = text.rfind('\\')
         if slashpos > -1:
             s = text[slashpos:]
             if s in latex_symbols:
                 # Try to complete a full latex symbol to unicode
                 # \\alpha -> α
                 return s, [latex_symbols[s]]
             else:
                 # If a user has partially typed a latex symbol, give them
                 # a full list of options \al -> [\aleph, \alpha]
                 matches = [k for k in latex_symbols if k.startswith(s)]
                 if matches:
                     return s, matches
         return '', ()
 
     def dispatch_custom_completer(self, text):
         if not self.custom_completers:
             return
 
         line = self.line_buffer
         if not line.strip():
             return None
 
         # Create a little structure to pass all the relevant information about
         # the current completion to any custom completer.
         event = SimpleNamespace()
         event.line = line
         event.symbol = text
         cmd = line.split(None,1)[0]
         event.command = cmd
         event.text_until_cursor = self.text_until_cursor
 
         # for foo etc, try also to find completer for %foo
         if not cmd.startswith(self.magic_escape):
             try_magic = self.custom_completers.s_matches(
                 self.magic_escape + cmd)
         else:
             try_magic = []
 
         for c in itertools.chain(self.custom_completers.s_matches(cmd),
                  try_magic,
                  self.custom_completers.flat_matches(self.text_until_cursor)):
             try:
                 res = c(event)
                 if res:
                     # first, try case sensitive match
                     withcase = [r for r in res if r.startswith(text)]
                     if withcase:
                         return withcase
                     # if none, then case insensitive ones are ok too
                     text_low = text.lower()
                     return [r for r in res if r.lower().startswith(text_low)]
             except TryNext:
                 pass
             except KeyboardInterrupt:
                 """
                 If custom completer take too long,
                 let keyboard interrupt abort and return nothing.
                 """
                 break
 
         return None
 
     def completions(self, text: str, offset: int)->Iterator[Completion]:
         """
         Returns an iterator over the possible completions
 
         .. warning::
 
             Unstable
 
             This function is unstable, API may change without warning.
             It will also raise unless use in proper context manager.
 
         Parameters
         ----------
         text : str
             Full text of the current input, multi line string.
         offset : int
             Integer representing the position of the cursor in ``text``. Offset
             is 0-based indexed.
 
         Yields
         ------
         Completion
 
         Notes
         -----
         The cursor on a text can either be seen as being "in between"
         characters or "On" a character depending on the interface visible to
         the user. For consistency the cursor being on "in between" characters X
         and Y is equivalent to the cursor being "on" character Y, that is to say
         the character the cursor is on is considered as being after the cursor.
 
         Combining characters may span more that one position in the
         text.
 
         .. note::
 
             If ``IPCompleter.debug`` is :any:`True` will yield a ``--jedi/ipython--``
             fake Completion token to distinguish completion returned by Jedi
             and usual IPython completion.
 
         .. note::
 
             Completions are not completely deduplicated yet. If identical
             completions are coming from different sources this function does not
             ensure that each completion object will only be present once.
         """
         warnings.warn("_complete is a provisional API (as of IPython 6.0). "
                       "It may change without warnings. "
                       "Use in corresponding context manager.",
                       category=ProvisionalCompleterWarning, stacklevel=2)
 
         seen = set()
         profiler:Optional[cProfile.Profile]
         try:
             if self.profile_completions:
                 import cProfile
                 profiler = cProfile.Profile()
                 profiler.enable()
             else:
                 profiler = None
 
             for c in self._completions(text, offset, _timeout=self.jedi_compute_type_timeout/1000):
                 if c and (c in seen):
                     continue
                 yield c
                 seen.add(c)
         except KeyboardInterrupt:
             """if completions take too long and users send keyboard interrupt,
             do not crash and return ASAP. """
             pass
         finally:
             if profiler is not None:
                 profiler.disable()
                 ensure_dir_exists(self.profiler_output_dir)
                 output_path = os.path.join(self.profiler_output_dir, str(uuid.uuid4()))
                 print("Writing profiler output to", output_path)
                 profiler.dump_stats(output_path)
 
     def _completions(self, full_text: str, offset: int, *, _timeout) -> Iterator[Completion]:
         """
         Core completion module.Same signature as :any:`completions`, with the
         extra `timeout` parameter (in seconds).
 
         Computing jedi's completion ``.type`` can be quite expensive (it is a
         lazy property) and can require some warm-up, more warm up than just
         computing the ``name`` of a completion. The warm-up can be :
 
             - Long warm-up the first time a module is encountered after
             install/update: actually build parse/inference tree.
 
             - first time the module is encountered in a session: load tree from
             disk.
 
         We don't want to block completions for tens of seconds so we give the
         completer a "budget" of ``_timeout`` seconds per invocation to compute
         completions types, the completions that have not yet been computed will
         be marked as "unknown" an will have a chance to be computed next round
         are things get cached.
 
         Keep in mind that Jedi is not the only thing treating the completion so
         keep the timeout short-ish as if we take more than 0.3 second we still
         have lots of processing to do.
 
         """
         deadline = time.monotonic() + _timeout
 
 
         before = full_text[:offset]
         cursor_line, cursor_column = position_to_cursor(full_text, offset)
 
         matched_text, matches, matches_origin, jedi_matches = self._complete(
             full_text=full_text, cursor_line=cursor_line, cursor_pos=cursor_column)
 
         iter_jm = iter(jedi_matches)
         if _timeout:
             for jm in iter_jm:
                 try:
                     type_ = jm.type
                 except Exception:
                     if self.debug:
                         print("Error in Jedi getting type of ", jm)
                     type_ = None
                 delta = len(jm.name_with_symbols) - len(jm.complete)
                 if type_ == 'function':
                     signature = _make_signature(jm)
                 else:
                     signature = ''
                 yield Completion(start=offset - delta,
                                  end=offset,
                                  text=jm.name_with_symbols,
                                  type=type_,
                                  signature=signature,
                                  _origin='jedi')
 
                 if time.monotonic() > deadline:
                     break
 
         for jm in iter_jm:
             delta = len(jm.name_with_symbols) - len(jm.complete)
             yield Completion(start=offset - delta,
                              end=offset,
                              text=jm.name_with_symbols,
                              type='<unknown>',  # don't compute type for speed
                              _origin='jedi',
                              signature='')
 
 
         start_offset = before.rfind(matched_text)
 
         # TODO:
         # Suppress this, right now just for debug.
         if jedi_matches and matches and self.debug:
             yield Completion(start=start_offset, end=offset, text='--jedi/ipython--',
                              _origin='debug', type='none', signature='')
 
         # I'm unsure if this is always true, so let's assert and see if it
         # crash
         assert before.endswith(matched_text)
         for m, t in zip(matches, matches_origin):
             yield Completion(start=start_offset, end=offset, text=m, _origin=t, signature='', type='<unknown>')
 
 
     def complete(self, text=None, line_buffer=None, cursor_pos=None) -> Tuple[str, Sequence[str]]:
         """Find completions for the given text and line context.
 
         Note that both the text and the line_buffer are optional, but at least
         one of them must be given.
 
         Parameters
         ----------
         text : string, optional
             Text to perform the completion on.  If not given, the line buffer
             is split using the instance's CompletionSplitter object.
         line_buffer : string, optional
             If not given, the completer attempts to obtain the current line
             buffer via readline.  This keyword allows clients which are
             requesting for text completions in non-readline contexts to inform
             the completer of the entire text.
         cursor_pos : int, optional
             Index of the cursor in the full line buffer.  Should be provided by
             remote frontends where kernel has no access to frontend state.
 
         Returns
         -------
         Tuple of two items:
         text : str
             Text that was actually used in the completion.
         matches : list
             A list of completion matches.
 
         Notes
         -----
             This API is likely to be deprecated and replaced by
             :any:`IPCompleter.completions` in the future.
 
         """
         warnings.warn('`Completer.complete` is pending deprecation since '
                 'IPython 6.0 and will be replaced by `Completer.completions`.',
                       PendingDeprecationWarning)
         # potential todo, FOLD the 3rd throw away argument of _complete
         # into the first 2 one.
         return self._complete(line_buffer=line_buffer, cursor_pos=cursor_pos, text=text, cursor_line=0)[:2]
 
     def _complete(self, *, cursor_line, cursor_pos, line_buffer=None, text=None,
                   full_text=None) -> _CompleteResult:
         """
         Like complete but can also returns raw jedi completions as well as the
         origin of the completion text. This could (and should) be made much
         cleaner but that will be simpler once we drop the old (and stateful)
         :any:`complete` API.
 
         With current provisional API, cursor_pos act both (depending on the
         caller) as the offset in the ``text`` or ``line_buffer``, or as the
         ``column`` when passing multiline strings this could/should be renamed
         but would add extra noise.
 
         Parameters
         ----------
         cursor_line
             Index of the line the cursor is on. 0 indexed.
         cursor_pos
             Position of the cursor in the current line/line_buffer/text. 0
             indexed.
         line_buffer : optional, str
             The current line the cursor is in, this is mostly due to legacy
             reason that readline could only give a us the single current line.
             Prefer `full_text`.
         text : str
             The current "token" the cursor is in, mostly also for historical
             reasons. as the completer would trigger only after the current line
             was parsed.
         full_text : str
             Full text of the current cell.
 
         Returns
         -------
         A tuple of N elements which are (likely):
             matched_text: ? the text that the complete matched
             matches: list of completions ?
             matches_origin: ? list same length as matches, and where each completion came from
             jedi_matches: list of Jedi matches, have it's own structure.
         """
 
 
         # if the cursor position isn't given, the only sane assumption we can
         # make is that it's at the end of the line (the common case)
         if cursor_pos is None:
             cursor_pos = len(line_buffer) if text is None else len(text)
 
         if self.use_main_ns:
             self.namespace = __main__.__dict__
 
         # if text is either None or an empty string, rely on the line buffer
         if (not line_buffer) and full_text:
             line_buffer = full_text.split('\n')[cursor_line]
         if not text: # issue #11508: check line_buffer before calling split_line
             text = self.splitter.split_line(line_buffer, cursor_pos)  if line_buffer else ''
 
         if self.backslash_combining_completions:
             # allow deactivation of these on windows.
             base_text = text if not line_buffer else line_buffer[:cursor_pos]
 
             for meth in (self.latex_matches,
                          self.unicode_name_matches,
                          back_latex_name_matches,
                          back_unicode_name_matches,
                          self.fwd_unicode_match):
                 name_text, name_matches = meth(base_text)
                 if name_text:
                     return _CompleteResult(name_text, name_matches[:MATCHES_LIMIT], \
                            [meth.__qualname__]*min(len(name_matches), MATCHES_LIMIT), ())
 
 
         # If no line buffer is given, assume the input text is all there was
         if line_buffer is None:
             line_buffer = text
 
         self.line_buffer = line_buffer
         self.text_until_cursor = self.line_buffer[:cursor_pos]
 
         # Do magic arg matches
         for matcher in self.magic_arg_matchers:
             matches = list(matcher(line_buffer))[:MATCHES_LIMIT]
             if matches:
                 origins = [matcher.__qualname__] * len(matches)
                 return _CompleteResult(text, matches, origins, ())
 
         # Start with a clean slate of completions
         matches = []
 
         # FIXME: we should extend our api to return a dict with completions for
         # different types of objects.  The rlcomplete() method could then
         # simply collapse the dict into a list for readline, but we'd have
         # richer completion semantics in other environments.
         is_magic_prefix = len(text) > 0 and text[0] == "%"
         completions: Iterable[Any] = []
         if self.use_jedi and not is_magic_prefix:
             if not full_text:
                 full_text = line_buffer
             completions = self._jedi_matches(
                 cursor_pos, cursor_line, full_text)
 
         if self.merge_completions:
             matches = []
             for matcher in self.matchers:
                 try:
                     matches.extend([(m, matcher.__qualname__)
                                     for m in matcher(text)])
                 except:
                     # Show the ugly traceback if the matcher causes an
                     # exception, but do NOT crash the kernel!
                     sys.excepthook(*sys.exc_info())
         else:
             for matcher in self.matchers:
                 matches = [(m, matcher.__qualname__)
                             for m in matcher(text)]
                 if matches:
                     break
                     
         seen = set()
         filtered_matches = set()
         for m in matches:
             t, c = m
             if t not in seen:
                 filtered_matches.add(m)
                 seen.add(t)
 
         _filtered_matches = sorted(filtered_matches, key=lambda x: completions_sorting_key(x[0]))
 
         custom_res = [(m, 'custom') for m in self.dispatch_custom_completer(text) or []]
         
         _filtered_matches = custom_res or _filtered_matches
         
         _filtered_matches = _filtered_matches[:MATCHES_LIMIT]
         _matches = [m[0] for m in _filtered_matches]
         origins = [m[1] for m in _filtered_matches]
 
         self.matches = _matches
 
         return _CompleteResult(text, _matches, origins, completions)
         
     def fwd_unicode_match(self, text:str) -> Tuple[str, Sequence[str]]:
         """
         Forward match a string starting with a backslash with a list of
         potential Unicode completions.
 
         Will compute list list of Unicode character names on first call and cache it.
 
         Returns
         -------
         At tuple with:
             - matched text (empty if no matches)
             - list of potential completions, empty tuple  otherwise)
         """
         # TODO: self.unicode_names is here a list we traverse each time with ~100k elements.
         # We could do a faster match using a Trie.
 
         # Using pygtrie the following seem to work:
 
         #     s = PrefixSet()
 
         #     for c in range(0,0x10FFFF + 1):
         #         try:
         #             s.add(unicodedata.name(chr(c)))
         #         except ValueError:
         #             pass
         #     [''.join(k) for k in s.iter(prefix)]
 
         # But need to be timed and adds an extra dependency.
 
         slashpos = text.rfind('\\')
         # if text starts with slash
         if slashpos > -1:
             # PERF: It's important that we don't access self._unicode_names
             # until we're inside this if-block. _unicode_names is lazily
             # initialized, and it takes a user-noticeable amount of time to
             # initialize it, so we don't want to initialize it unless we're
             # actually going to use it.
             s = text[slashpos + 1 :]
             sup = s.upper()
             candidates = [x for x in self.unicode_names if x.startswith(sup)]
             if candidates:
                 return s, candidates
             candidates = [x for x in self.unicode_names if sup in x]
             if candidates:
                 return s, candidates
             splitsup = sup.split(" ")
             candidates = [
                 x for x in self.unicode_names if all(u in x for u in splitsup)
             ]
             if candidates:
                 return s, candidates
 
             return "", ()
 
         # if text does not start with slash
         else:
             return '', ()
 
     @property
     def unicode_names(self) -> List[str]:
         """List of names of unicode code points that can be completed.
 
         The list is lazily initialized on first access.
         """
         if self._unicode_names is None:
             names = []
             for c in range(0,0x10FFFF + 1):
                 try:
                     names.append(unicodedata.name(chr(c)))
                 except ValueError:
                     pass
             self._unicode_names = _unicode_name_compute(_UNICODE_RANGES)
 
         return self._unicode_names
 
 def _unicode_name_compute(ranges:List[Tuple[int,int]]) -> List[str]:
     names = []
     for start,stop in ranges:
         for c in range(start, stop) :
             try:
                 names.append(unicodedata.name(chr(c)))
             except ValueError:
                 pass
     return names

IPython/core/history.py

@@ -1,913 +1,913 b''
 """ History related magics and functionality """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 import atexit
 import datetime
 from pathlib import Path
 import re
 import sqlite3
 import threading
 
 from traitlets.config.configurable import LoggingConfigurable
 from decorator import decorator
 from IPython.utils.decorators import undoc
 from IPython.paths import locate_profile
 from traitlets import (
     Any,
     Bool,
     Dict,
     Instance,
     Integer,
     List,
     Unicode,
     Union,
     TraitError,
     default,
     observe,
 )
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 @undoc
 class DummyDB(object):
     """Dummy DB that will act as a black hole for history.
 
     Only used in the absence of sqlite"""
     def execute(*args, **kwargs):
         return []
 
     def commit(self, *args, **kwargs):
         pass
 
     def __enter__(self, *args, **kwargs):
         pass
 
     def __exit__(self, *args, **kwargs):
         pass
 
 
 @decorator
 def only_when_enabled(f, self, *a, **kw):
     """Decorator: return an empty list in the absence of sqlite."""
     if not self.enabled:
         return []
     else:
         return f(self, *a, **kw)
 
 
 # use 16kB as threshold for whether a corrupt history db should be saved
 # that should be at least 100 entries or so
 _SAVE_DB_SIZE = 16384
 
 @decorator
 def catch_corrupt_db(f, self, *a, **kw):
     """A decorator which wraps HistoryAccessor method calls to catch errors from
     a corrupt SQLite database, move the old database out of the way, and create
     a new one.
 
     We avoid clobbering larger databases because this may be triggered due to filesystem issues,
     not just a corrupt file.
     """
     try:
         return f(self, *a, **kw)
     except (sqlite3.DatabaseError, sqlite3.OperationalError) as e:
         self._corrupt_db_counter += 1
         self.log.error("Failed to open SQLite history %s (%s).", self.hist_file, e)
         if self.hist_file != ':memory:':
             if self._corrupt_db_counter > self._corrupt_db_limit:
                 self.hist_file = ':memory:'
                 self.log.error("Failed to load history too many times, history will not be saved.")
             elif self.hist_file.is_file():
                 # move the file out of the way
                 base = str(self.hist_file.parent / self.hist_file.stem)
                 ext = self.hist_file.suffix
                 size = self.hist_file.stat().st_size
                 if size >= _SAVE_DB_SIZE:
                     # if there's significant content, avoid clobbering
                     now = datetime.datetime.now().isoformat().replace(':', '.')
                     newpath = base + '-corrupt-' + now + ext
                     # don't clobber previous corrupt backups
                     for i in range(100):
                         if not Path(newpath).exists():
                             break
                         else:
                             newpath = base + '-corrupt-' + now + (u'-%i' % i) + ext
                 else:
                     # not much content, possibly empty; don't worry about clobbering
                     # maybe we should just delete it?
                     newpath = base + '-corrupt' + ext
                 self.hist_file.rename(newpath)
                 self.log.error("History file was moved to %s and a new file created.", newpath)
             self.init_db()
             return []
         else:
             # Failed with :memory:, something serious is wrong
             raise
 
 
 class HistoryAccessorBase(LoggingConfigurable):
     """An abstract class for History Accessors """
 
     def get_tail(self, n=10, raw=True, output=False, include_latest=False):
         raise NotImplementedError
 
     def search(self, pattern="*", raw=True, search_raw=True,
                output=False, n=None, unique=False):
         raise NotImplementedError
 
     def get_range(self, session, start=1, stop=None, raw=True,output=False):
         raise NotImplementedError
 
     def get_range_by_str(self, rangestr, raw=True, output=False):
         raise NotImplementedError
 
 
 class HistoryAccessor(HistoryAccessorBase):
     """Access the history database without adding to it.
 
     This is intended for use by standalone history tools. IPython shells use
     HistoryManager, below, which is a subclass of this."""
 
     # counter for init_db retries, so we don't keep trying over and over
     _corrupt_db_counter = 0
      # after two failures, fallback on :memory:
     _corrupt_db_limit = 2
 
     # String holding the path to the history file
     hist_file = Union(
         [Instance(Path), Unicode()],
         help="""Path to file to use for SQLite history database.
 
         By default, IPython will put the history database in the IPython
         profile directory.  If you would rather share one history among
         profiles, you can set this value in each, so that they are consistent.
 
         Due to an issue with fcntl, SQLite is known to misbehave on some NFS
         mounts.  If you see IPython hanging, try setting this to something on a
         local disk, e.g::
 
             ipython --HistoryManager.hist_file=/tmp/ipython_hist.sqlite
 
         you can also use the specific value `:memory:` (including the colon
         at both end but not the back ticks), to avoid creating an history file.
 
         """,
     ).tag(config=True)
 
     enabled = Bool(True,
         help="""enable the SQLite history
 
         set enabled=False to disable the SQLite history,
         in which case there will be no stored history, no SQLite connection,
         and no background saving thread.  This may be necessary in some
         threaded environments where IPython is embedded.
-        """
+        """,
     ).tag(config=True)
 
     connection_options = Dict(
         help="""Options for configuring the SQLite connection
 
         These options are passed as keyword args to sqlite3.connect
         when establishing database connections.
         """
     ).tag(config=True)
 
     # The SQLite database
     db = Any()
     @observe('db')
     def _db_changed(self, change):
         """validate the db, since it can be an Instance of two different types"""
         new = change['new']
         connection_types = (DummyDB, sqlite3.Connection)
         if not isinstance(new, connection_types):
             msg = "%s.db must be sqlite3 Connection or DummyDB, not %r" % \
                     (self.__class__.__name__, new)
             raise TraitError(msg)
 
     def __init__(self, profile="default", hist_file="", **traits):
         """Create a new history accessor.
 
         Parameters
         ----------
         profile : str
             The name of the profile from which to open history.
         hist_file : str
             Path to an SQLite history database stored by IPython. If specified,
             hist_file overrides profile.
         config : :class:`~traitlets.config.loader.Config`
             Config object. hist_file can also be set through this.
         """
         # We need a pointer back to the shell for various tasks.
         super(HistoryAccessor, self).__init__(**traits)
         # defer setting hist_file from kwarg until after init,
         # otherwise the default kwarg value would clobber any value
         # set by config
         if hist_file:
             self.hist_file = hist_file
 
         try:
             self.hist_file
         except TraitError:
             # No one has set the hist_file, yet.
             self.hist_file = self._get_hist_file_name(profile)
 
         self.init_db()
 
     def _get_hist_file_name(self, profile='default'):
         """Find the history file for the given profile name.
 
         This is overridden by the HistoryManager subclass, to use the shell's
         active profile.
 
         Parameters
         ----------
         profile : str
             The name of a profile which has a history file.
         """
         return Path(locate_profile(profile)) / "history.sqlite"
 
     @catch_corrupt_db
     def init_db(self):
         """Connect to the database, and create tables if necessary."""
         if not self.enabled:
             self.db = DummyDB()
             return
 
         # use detect_types so that timestamps return datetime objects
         kwargs = dict(detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
         kwargs.update(self.connection_options)
         self.db = sqlite3.connect(str(self.hist_file), **kwargs)
         with self.db:
             self.db.execute(
                 """CREATE TABLE IF NOT EXISTS sessions (session integer
                             primary key autoincrement, start timestamp,
                             end timestamp, num_cmds integer, remark text)"""
             )
             self.db.execute(
                 """CREATE TABLE IF NOT EXISTS history
                     (session integer, line integer, source text, source_raw text,
                     PRIMARY KEY (session, line))"""
             )
             # Output history is optional, but ensure the table's there so it can be
             # enabled later.
             self.db.execute(
                 """CREATE TABLE IF NOT EXISTS output_history
                             (session integer, line integer, output text,
                             PRIMARY KEY (session, line))"""
             )
         # success! reset corrupt db count
         self._corrupt_db_counter = 0
 
     def writeout_cache(self):
         """Overridden by HistoryManager to dump the cache before certain
         database lookups."""
         pass
 
     ## -------------------------------
     ## Methods for retrieving history:
     ## -------------------------------
     def _run_sql(self, sql, params, raw=True, output=False, latest=False):
         """Prepares and runs an SQL query for the history database.
 
         Parameters
         ----------
         sql : str
             Any filtering expressions to go after SELECT ... FROM ...
         params : tuple
             Parameters passed to the SQL query (to replace "?")
         raw, output : bool
             See :meth:`get_range`
         latest : bool
             Select rows with max (session, line)
 
         Returns
         -------
         Tuples as :meth:`get_range`
         """
         toget = 'source_raw' if raw else 'source'
         sqlfrom = "history"
         if output:
             sqlfrom = "history LEFT JOIN output_history USING (session, line)"
             toget = "history.%s, output_history.output" % toget
         if latest:
             toget += ", MAX(session * 128 * 1024 + line)"
         cur = self.db.execute("SELECT session, line, %s FROM %s " %\
                                 (toget, sqlfrom) + sql, params)
         if latest:
             cur = (row[:-1] for row in cur)
         if output:    # Regroup into 3-tuples, and parse JSON
             return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)
         return cur
 
     @only_when_enabled
     @catch_corrupt_db
     def get_session_info(self, session):
         """Get info about a session.
 
         Parameters
         ----------
         session : int
             Session number to retrieve.
 
         Returns
         -------
         session_id : int
             Session ID number
         start : datetime
             Timestamp for the start of the session.
         end : datetime
             Timestamp for the end of the session, or None if IPython crashed.
         num_cmds : int
             Number of commands run, or None if IPython crashed.
         remark : unicode
             A manually set description.
         """
         query = "SELECT * from sessions where session == ?"
         return self.db.execute(query, (session,)).fetchone()
 
     @catch_corrupt_db
     def get_last_session_id(self):
         """Get the last session ID currently in the database.
 
         Within IPython, this should be the same as the value stored in
         :attr:`HistoryManager.session_number`.
         """
         for record in self.get_tail(n=1, include_latest=True):
             return record[0]
 
     @catch_corrupt_db
     def get_tail(self, n=10, raw=True, output=False, include_latest=False):
         """Get the last n lines from the history database.
 
         Parameters
         ----------
         n : int
             The number of lines to get
         raw, output : bool
             See :meth:`get_range`
         include_latest : bool
             If False (default), n+1 lines are fetched, and the latest one
             is discarded. This is intended to be used where the function
             is called by a user command, which it should not return.
 
         Returns
         -------
         Tuples as :meth:`get_range`
         """
         self.writeout_cache()
         if not include_latest:
             n += 1
         cur = self._run_sql("ORDER BY session DESC, line DESC LIMIT ?",
                                 (n,), raw=raw, output=output)
         if not include_latest:
             return reversed(list(cur)[1:])
         return reversed(list(cur))
 
     @catch_corrupt_db
     def search(self, pattern="*", raw=True, search_raw=True,
                output=False, n=None, unique=False):
         """Search the database using unix glob-style matching (wildcards
         * and ?).
 
         Parameters
         ----------
         pattern : str
             The wildcarded pattern to match when searching
         search_raw : bool
             If True, search the raw input, otherwise, the parsed input
         raw, output : bool
             See :meth:`get_range`
         n : None or int
             If an integer is given, it defines the limit of
             returned entries.
         unique : bool
             When it is true, return only unique entries.
 
         Returns
         -------
         Tuples as :meth:`get_range`
         """
         tosearch = "source_raw" if search_raw else "source"
         if output:
             tosearch = "history." + tosearch
         self.writeout_cache()
         sqlform = "WHERE %s GLOB ?" % tosearch
         params = (pattern,)
         if unique:
             sqlform += ' GROUP BY {0}'.format(tosearch)
         if n is not None:
             sqlform += " ORDER BY session DESC, line DESC LIMIT ?"
             params += (n,)
         elif unique:
             sqlform += " ORDER BY session, line"
         cur = self._run_sql(sqlform, params, raw=raw, output=output, latest=unique)
         if n is not None:
             return reversed(list(cur))
         return cur
 
     @catch_corrupt_db
     def get_range(self, session, start=1, stop=None, raw=True,output=False):
         """Retrieve input by session.
 
         Parameters
         ----------
         session : int
             Session number to retrieve.
         start : int
             First line to retrieve.
         stop : int
             End of line range (excluded from output itself). If None, retrieve
             to the end of the session.
         raw : bool
             If True, return untranslated input
         output : bool
             If True, attempt to include output. This will be 'real' Python
             objects for the current session, or text reprs from previous
             sessions if db_log_output was enabled at the time. Where no output
             is found, None is used.
 
         Returns
         -------
         entries
             An iterator over the desired lines. Each line is a 3-tuple, either
             (session, line, input) if output is False, or
             (session, line, (input, output)) if output is True.
         """
         if stop:
             lineclause = "line >= ? AND line < ?"
             params = (session, start, stop)
         else:
             lineclause = "line>=?"
             params = (session, start)
 
         return self._run_sql("WHERE session==? AND %s" % lineclause,
                                     params, raw=raw, output=output)
 
     def get_range_by_str(self, rangestr, raw=True, output=False):
         """Get lines of history from a string of ranges, as used by magic
         commands %hist, %save, %macro, etc.
 
         Parameters
         ----------
         rangestr : str
             A string specifying ranges, e.g. "5 ~2/1-4". If empty string is used,
             this will return everything from current session's history.
 
             See the documentation of :func:`%history` for the full details.
 
         raw, output : bool
             As :meth:`get_range`
 
         Returns
         -------
         Tuples as :meth:`get_range`
         """
         for sess, s, e in extract_hist_ranges(rangestr):
             for line in self.get_range(sess, s, e, raw=raw, output=output):
                 yield line
 
 
 class HistoryManager(HistoryAccessor):
     """A class to organize all history-related functionality in one place.
     """
     # Public interface
 
     # An instance of the IPython shell we are attached to
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                      allow_none=True)
     # Lists to hold processed and raw history. These start with a blank entry
     # so that we can index them starting from 1
     input_hist_parsed = List([""])
     input_hist_raw = List([""])
     # A list of directories visited during session
     dir_hist = List()
     @default('dir_hist')
     def _dir_hist_default(self):
         try:
             return [Path.cwd()]
         except OSError:
             return []
 
     # A dict of output history, keyed with ints from the shell's
     # execution count.
     output_hist = Dict()
     # The text/plain repr of outputs.
     output_hist_reprs = Dict()
 
     # The number of the current session in the history database
     session_number = Integer()
 
     db_log_output = Bool(False,
         help="Should the history database include output? (default: no)"
     ).tag(config=True)
     db_cache_size = Integer(0,
         help="Write to database every x commands (higher values save disk access & power).\n"
         "Values of 1 or less effectively disable caching."
     ).tag(config=True)
     # The input and output caches
     db_input_cache = List()
     db_output_cache = List()
 
     # History saving in separate thread
     save_thread = Instance('IPython.core.history.HistorySavingThread',
                            allow_none=True)
     save_flag = Instance(threading.Event, allow_none=True)
 
     # Private interface
     # Variables used to store the three last inputs from the user.  On each new
     # history update, we populate the user's namespace with these, shifted as
     # necessary.
     _i00 = Unicode(u'')
     _i = Unicode(u'')
     _ii = Unicode(u'')
     _iii = Unicode(u'')
 
     # A regex matching all forms of the exit command, so that we don't store
     # them in the history (it's annoying to rewind the first entry and land on
     # an exit call).
     _exit_re = re.compile(r"(exit|quit)(\s*\(.*\))?$")
 
     def __init__(self, shell=None, config=None, **traits):
         """Create a new history manager associated with a shell instance.
         """
         # We need a pointer back to the shell for various tasks.
         super(HistoryManager, self).__init__(shell=shell, config=config,
             **traits)
         self.save_flag = threading.Event()
         self.db_input_cache_lock = threading.Lock()
         self.db_output_cache_lock = threading.Lock()
 
         try:
             self.new_session()
         except sqlite3.OperationalError:
             self.log.error("Failed to create history session in %s. History will not be saved.",
                 self.hist_file, exc_info=True)
             self.hist_file = ':memory:'
 
         if self.enabled and self.hist_file != ':memory:':
             self.save_thread = HistorySavingThread(self)
             self.save_thread.start()
 
     def _get_hist_file_name(self, profile=None):
         """Get default history file name based on the Shell's profile.
 
         The profile parameter is ignored, but must exist for compatibility with
         the parent class."""
         profile_dir = self.shell.profile_dir.location
         return Path(profile_dir) / "history.sqlite"
 
     @only_when_enabled
     def new_session(self, conn=None):
         """Get a new session number."""
         if conn is None:
             conn = self.db
 
         with conn:
             cur = conn.execute("""INSERT INTO sessions VALUES (NULL, ?, NULL,
                             NULL, "") """, (datetime.datetime.now(),))
             self.session_number = cur.lastrowid
 
     def end_session(self):
         """Close the database session, filling in the end time and line count."""
         self.writeout_cache()
         with self.db:
             self.db.execute("""UPDATE sessions SET end=?, num_cmds=? WHERE
                             session==?""", (datetime.datetime.now(),
                             len(self.input_hist_parsed)-1, self.session_number))
         self.session_number = 0
 
     def name_session(self, name):
         """Give the current session a name in the history database."""
         with self.db:
             self.db.execute("UPDATE sessions SET remark=? WHERE session==?",
                             (name, self.session_number))
 
     def reset(self, new_session=True):
         """Clear the session history, releasing all object references, and
         optionally open a new session."""
         self.output_hist.clear()
         # The directory history can't be completely empty
         self.dir_hist[:] = [Path.cwd()]
 
         if new_session:
             if self.session_number:
                 self.end_session()
             self.input_hist_parsed[:] = [""]
             self.input_hist_raw[:] = [""]
             self.new_session()
 
     # ------------------------------
     # Methods for retrieving history
     # ------------------------------
     def get_session_info(self, session=0):
         """Get info about a session.
 
         Parameters
         ----------
         session : int
             Session number to retrieve. The current session is 0, and negative
             numbers count back from current session, so -1 is the previous session.
 
         Returns
         -------
         session_id : int
             Session ID number
         start : datetime
             Timestamp for the start of the session.
         end : datetime
             Timestamp for the end of the session, or None if IPython crashed.
         num_cmds : int
             Number of commands run, or None if IPython crashed.
         remark : unicode
             A manually set description.
         """
         if session <= 0:
             session += self.session_number
 
         return super(HistoryManager, self).get_session_info(session=session)
 
     def _get_range_session(self, start=1, stop=None, raw=True, output=False):
         """Get input and output history from the current session. Called by
         get_range, and takes similar parameters."""
         input_hist = self.input_hist_raw if raw else self.input_hist_parsed
 
         n = len(input_hist)
         if start < 0:
             start += n
         if not stop or (stop > n):
             stop = n
         elif stop < 0:
             stop += n
 
         for i in range(start, stop):
             if output:
                 line = (input_hist[i], self.output_hist_reprs.get(i))
             else:
                 line = input_hist[i]
             yield (0, i, line)
 
     def get_range(self, session=0, start=1, stop=None, raw=True,output=False):
         """Retrieve input by session.
 
         Parameters
         ----------
         session : int
             Session number to retrieve. The current session is 0, and negative
             numbers count back from current session, so -1 is previous session.
         start : int
             First line to retrieve.
         stop : int
             End of line range (excluded from output itself). If None, retrieve
             to the end of the session.
         raw : bool
             If True, return untranslated input
         output : bool
             If True, attempt to include output. This will be 'real' Python
             objects for the current session, or text reprs from previous
             sessions if db_log_output was enabled at the time. Where no output
             is found, None is used.
 
         Returns
         -------
         entries
             An iterator over the desired lines. Each line is a 3-tuple, either
             (session, line, input) if output is False, or
             (session, line, (input, output)) if output is True.
         """
         if session <= 0:
             session += self.session_number
         if session==self.session_number:          # Current session
             return self._get_range_session(start, stop, raw, output)
         return super(HistoryManager, self).get_range(session, start, stop, raw,
                                                      output)
 
     ## ----------------------------
     ## Methods for storing history:
     ## ----------------------------
     def store_inputs(self, line_num, source, source_raw=None):
         """Store source and raw input in history and create input cache
         variables ``_i*``.
 
         Parameters
         ----------
         line_num : int
             The prompt number of this input.
         source : str
             Python input.
         source_raw : str, optional
             If given, this is the raw input without any IPython transformations
             applied to it.  If not given, ``source`` is used.
         """
         if source_raw is None:
             source_raw = source
         source = source.rstrip('\n')
         source_raw = source_raw.rstrip('\n')
 
         # do not store exit/quit commands
         if self._exit_re.match(source_raw.strip()):
             return
 
         self.input_hist_parsed.append(source)
         self.input_hist_raw.append(source_raw)
 
         with self.db_input_cache_lock:
             self.db_input_cache.append((line_num, source, source_raw))
             # Trigger to flush cache and write to DB.
             if len(self.db_input_cache) >= self.db_cache_size:
                 self.save_flag.set()
 
         # update the auto _i variables
         self._iii = self._ii
         self._ii = self._i
         self._i = self._i00
         self._i00 = source_raw
 
         # hackish access to user namespace to create _i1,_i2... dynamically
         new_i = '_i%s' % line_num
         to_main = {'_i': self._i,
                    '_ii': self._ii,
                    '_iii': self._iii,
                    new_i : self._i00 }
 
         if self.shell is not None:
             self.shell.push(to_main, interactive=False)
 
     def store_output(self, line_num):
         """If database output logging is enabled, this saves all the
         outputs from the indicated prompt number to the database. It's
         called by run_cell after code has been executed.
 
         Parameters
         ----------
         line_num : int
             The line number from which to save outputs
         """
         if (not self.db_log_output) or (line_num not in self.output_hist_reprs):
             return
         output = self.output_hist_reprs[line_num]
 
         with self.db_output_cache_lock:
             self.db_output_cache.append((line_num, output))
         if self.db_cache_size <= 1:
             self.save_flag.set()
 
     def _writeout_input_cache(self, conn):
         with conn:
             for line in self.db_input_cache:
                 conn.execute("INSERT INTO history VALUES (?, ?, ?, ?)",
                                 (self.session_number,)+line)
 
     def _writeout_output_cache(self, conn):
         with conn:
             for line in self.db_output_cache:
                 conn.execute("INSERT INTO output_history VALUES (?, ?, ?)",
                                 (self.session_number,)+line)
 
     @only_when_enabled
     def writeout_cache(self, conn=None):
         """Write any entries in the cache to the database."""
         if conn is None:
             conn = self.db
 
         with self.db_input_cache_lock:
             try:
                 self._writeout_input_cache(conn)
             except sqlite3.IntegrityError:
                 self.new_session(conn)
                 print("ERROR! Session/line number was not unique in",
                       "database. History logging moved to new session",
                                                 self.session_number)
                 try:
                     # Try writing to the new session. If this fails, don't
                     # recurse
                     self._writeout_input_cache(conn)
                 except sqlite3.IntegrityError:
                     pass
             finally:
                 self.db_input_cache = []
 
         with self.db_output_cache_lock:
             try:
                 self._writeout_output_cache(conn)
             except sqlite3.IntegrityError:
                 print("!! Session/line number for output was not unique",
                       "in database. Output will not be stored.")
             finally:
                 self.db_output_cache = []
 
 
 class HistorySavingThread(threading.Thread):
     """This thread takes care of writing history to the database, so that
     the UI isn't held up while that happens.
 
     It waits for the HistoryManager's save_flag to be set, then writes out
     the history cache. The main thread is responsible for setting the flag when
     the cache size reaches a defined threshold."""
     daemon = True
     stop_now = False
     enabled = True
     def __init__(self, history_manager):
         super(HistorySavingThread, self).__init__(name="IPythonHistorySavingThread")
         self.history_manager = history_manager
         self.enabled = history_manager.enabled
         atexit.register(self.stop)
 
     @only_when_enabled
     def run(self):
         # We need a separate db connection per thread:
         try:
             self.db = sqlite3.connect(
                 str(self.history_manager.hist_file),
                 **self.history_manager.connection_options,
             )
             while True:
                 self.history_manager.save_flag.wait()
                 if self.stop_now:
                     self.db.close()
                     return
                 self.history_manager.save_flag.clear()
                 self.history_manager.writeout_cache(self.db)
         except Exception as e:
             print(("The history saving thread hit an unexpected error (%s)."
                    "History will not be written to the database.") % repr(e))
 
     def stop(self):
         """This can be called from the main thread to safely stop this thread.
 
         Note that it does not attempt to write out remaining history before
         exiting. That should be done by calling the HistoryManager's
         end_session method."""
         self.stop_now = True
         self.history_manager.save_flag.set()
         self.join()
 
 
 # To match, e.g. ~5/8-~2/3
 range_re = re.compile(r"""
 ((?P<startsess>~?\d+)/)?
 (?P<start>\d+)?
 ((?P<sep>[\-:])
  ((?P<endsess>~?\d+)/)?
  (?P<end>\d+))?
 $""", re.VERBOSE)
 
 
 def extract_hist_ranges(ranges_str):
     """Turn a string of history ranges into 3-tuples of (session, start, stop).
 
     Empty string results in a `[(0, 1, None)]`, i.e. "everything from current
     session".
 
     Examples
     --------
     >>> list(extract_hist_ranges("~8/5-~7/4 2"))
     [(-8, 5, None), (-7, 1, 5), (0, 2, 3)]
     """
     if ranges_str == "":
         yield (0, 1, None)  # Everything from current session
         return
 
     for range_str in ranges_str.split():
         rmatch = range_re.match(range_str)
         if not rmatch:
             continue
         start = rmatch.group("start")
         if start:
             start = int(start)
             end = rmatch.group("end")
             # If no end specified, get (a, a + 1)
             end = int(end) if end else start + 1
         else:  # start not specified
             if not rmatch.group('startsess'):  # no startsess
                 continue
             start = 1
             end = None  # provide the entire session hist
 
         if rmatch.group("sep") == "-":       # 1-3 == 1:4 --> [1, 2, 3]
             end += 1
         startsess = rmatch.group("startsess") or "0"
         endsess = rmatch.group("endsess") or startsess
         startsess = int(startsess.replace("~","-"))
         endsess = int(endsess.replace("~","-"))
         assert endsess >= startsess, "start session must be earlier than end session"
 
         if endsess == startsess:
             yield (startsess, start, end)
             continue
         # Multiple sessions in one range:
         yield (startsess, start, None)
         for sess in range(startsess+1, endsess):
             yield (sess, 1, None)
         yield (endsess, 1, end)
 
 
 def _format_lineno(session, line):
     """Helper function to format line numbers properly."""
     if session == 0:
         return str(line)
     return "%s#%s" % (session, line)

IPython/core/magics/script.py

@@ -1,362 +1,362 b''
 """Magic functions for running cells in various scripts."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import asyncio
 import atexit
 import errno
 import os
 import signal
 import sys
 import time
 from subprocess import CalledProcessError
 from threading import Thread
 
 from traitlets import Any, Dict, List, default
 
 from IPython.core import magic_arguments
 from IPython.core.async_helpers import _AsyncIOProxy
 from IPython.core.magic import Magics, cell_magic, line_magic, magics_class
 from IPython.utils.process import arg_split
 
 #-----------------------------------------------------------------------------
 # Magic implementation classes
 #-----------------------------------------------------------------------------
 
 def script_args(f):
     """single decorator for adding script args"""
     args = [
         magic_arguments.argument(
             '--out', type=str,
             help="""The variable in which to store stdout from the script.
             If the script is backgrounded, this will be the stdout *pipe*,
             instead of the stderr text itself and will not be auto closed.
             """
         ),
         magic_arguments.argument(
             '--err', type=str,
             help="""The variable in which to store stderr from the script.
             If the script is backgrounded, this will be the stderr *pipe*,
             instead of the stderr text itself and will not be autoclosed.
             """
         ),
         magic_arguments.argument(
             '--bg', action="store_true",
             help="""Whether to run the script in the background.
             If given, the only way to see the output of the command is
             with --out/err.
             """
         ),
         magic_arguments.argument(
             '--proc', type=str,
             help="""The variable in which to store Popen instance.
             This is used only when --bg option is given.
             """
         ),
         magic_arguments.argument(
             '--no-raise-error', action="store_false", dest='raise_error',
             help="""Whether you should raise an error message in addition to
             a stream on stderr if you get a nonzero exit code.
-            """
-        )
+            """,
+        ),
     ]
     for arg in args:
         f = arg(f)
     return f
 
 
 @magics_class
 class ScriptMagics(Magics):
     """Magics for talking to scripts
     
     This defines a base `%%script` cell magic for running a cell
     with a program in a subprocess, and registers a few top-level
     magics that call %%script with common interpreters.
     """
 
     event_loop = Any(
         help="""
         The event loop on which to run subprocesses
 
         Not the main event loop,
         because we want to be able to make blocking calls
         and have certain requirements we don't want to impose on the main loop.
         """
     )
 
     script_magics = List(
         help="""Extra script cell magics to define
         
         This generates simple wrappers of `%%script foo` as `%%foo`.
         
         If you want to add script magics that aren't on your path,
         specify them in script_paths
         """,
     ).tag(config=True)
     @default('script_magics')
     def _script_magics_default(self):
         """default to a common list of programs"""
         
         defaults = [
             'sh',
             'bash',
             'perl',
             'ruby',
             'python',
             'python2',
             'python3',
             'pypy',
         ]
         if os.name == 'nt':
             defaults.extend([
                 'cmd',
             ])
         
         return defaults
     
     script_paths = Dict(
         help="""Dict mapping short 'ruby' names to full paths, such as '/opt/secret/bin/ruby'
         
         Only necessary for items in script_magics where the default path will not
         find the right interpreter.
         """
     ).tag(config=True)
     
     def __init__(self, shell=None):
         super(ScriptMagics, self).__init__(shell=shell)
         self._generate_script_magics()
         self.bg_processes = []
         atexit.register(self.kill_bg_processes)
 
     def __del__(self):
         self.kill_bg_processes()
     
     def _generate_script_magics(self):
         cell_magics = self.magics['cell']
         for name in self.script_magics:
             cell_magics[name] = self._make_script_magic(name)
     
     def _make_script_magic(self, name):
         """make a named magic, that calls %%script with a particular program"""
         # expand to explicit path if necessary:
         script = self.script_paths.get(name, name)
         
         @magic_arguments.magic_arguments()
         @script_args
         def named_script_magic(line, cell):
             # if line, add it as cl-flags
             if line:
                 line = "%s %s" % (script, line)
             else:
                 line = script
             return self.shebang(line, cell)
         
         # write a basic docstring:
         named_script_magic.__doc__ = \
         """%%{name} script magic
         
         Run cells with {script} in a subprocess.
         
         This is a shortcut for `%%script {script}`
         """.format(**locals())
         
         return named_script_magic
     
     @magic_arguments.magic_arguments()
     @script_args
     @cell_magic("script")
     def shebang(self, line, cell):
         """Run a cell via a shell command
 
         The `%%script` line is like the #! line of script,
         specifying a program (bash, perl, ruby, etc.) with which to run.
 
         The rest of the cell is run by that program.
 
         Examples
         --------
         ::
 
             In [1]: %%script bash
                ...: for i in 1 2 3; do
                ...:   echo $i
                ...: done
             1
             2
             3
         """
 
         # Create the event loop in which to run script magics
         # this operates on a background thread
         if self.event_loop is None:
             if sys.platform == "win32":
                 # don't override the current policy,
                 # just create an event loop
                 event_loop = asyncio.WindowsProactorEventLoopPolicy().new_event_loop()
             else:
                 event_loop = asyncio.new_event_loop()
             self.event_loop = event_loop
 
             # start the loop in a background thread
             asyncio_thread = Thread(target=event_loop.run_forever, daemon=True)
             asyncio_thread.start()
         else:
             event_loop = self.event_loop
 
         def in_thread(coro):
             """Call a coroutine on the asyncio thread"""
             return asyncio.run_coroutine_threadsafe(coro, event_loop).result()
 
         async def _handle_stream(stream, stream_arg, file_object):
             while True:
                 line = (await stream.readline()).decode("utf8")
                 if not line:
                     break
                 if stream_arg:
                     self.shell.user_ns[stream_arg] = line
                 else:
                     file_object.write(line)
                     file_object.flush()
 
         async def _stream_communicate(process, cell):
             process.stdin.write(cell)
             process.stdin.close()
             stdout_task = asyncio.create_task(
                 _handle_stream(process.stdout, args.out, sys.stdout)
             )
             stderr_task = asyncio.create_task(
                 _handle_stream(process.stderr, args.err, sys.stderr)
             )
             await asyncio.wait([stdout_task, stderr_task])
             await process.wait()
 
         argv = arg_split(line, posix=not sys.platform.startswith("win"))
         args, cmd = self.shebang.parser.parse_known_args(argv)
 
         try:
             p = in_thread(
                 asyncio.create_subprocess_exec(
                     *cmd,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
                     stdin=asyncio.subprocess.PIPE,
                 )
             )
         except OSError as e:
             if e.errno == errno.ENOENT:
                 print("Couldn't find program: %r" % cmd[0])
                 return
             else:
                 raise
 
         if not cell.endswith('\n'):
             cell += '\n'
         cell = cell.encode('utf8', 'replace')
         if args.bg:
             self.bg_processes.append(p)
             self._gc_bg_processes()
             to_close = []
             if args.out:
                 self.shell.user_ns[args.out] = _AsyncIOProxy(p.stdout, event_loop)
             else:
                 to_close.append(p.stdout)
             if args.err:
                 self.shell.user_ns[args.err] = _AsyncIOProxy(p.stderr, event_loop)
             else:
                 to_close.append(p.stderr)
             event_loop.call_soon_threadsafe(
                 lambda: asyncio.Task(self._run_script(p, cell, to_close))
             )
             if args.proc:
                 proc_proxy = _AsyncIOProxy(p, event_loop)
                 proc_proxy.stdout = _AsyncIOProxy(p.stdout, event_loop)
                 proc_proxy.stderr = _AsyncIOProxy(p.stderr, event_loop)
                 self.shell.user_ns[args.proc] = proc_proxy
             return
 
         try:
             in_thread(_stream_communicate(p, cell))
         except KeyboardInterrupt:
             try:
                 p.send_signal(signal.SIGINT)
                 in_thread(asyncio.wait_for(p.wait(), timeout=0.1))
                 if p.returncode is not None:
                     print("Process is interrupted.")
                     return
                 p.terminate()
                 in_thread(asyncio.wait_for(p.wait(), timeout=0.1))
                 if p.returncode is not None:
                     print("Process is terminated.")
                     return
                 p.kill()
                 print("Process is killed.")
             except OSError:
                 pass
             except Exception as e:
                 print("Error while terminating subprocess (pid=%i): %s" % (p.pid, e))
             return
 
         if args.raise_error and p.returncode != 0:
             # If we get here and p.returncode is still None, we must have
             # killed it but not yet seen its return code. We don't wait for it,
             # in case it's stuck in uninterruptible sleep. -9 = SIGKILL
             rc = p.returncode or -9
             raise CalledProcessError(rc, cell)
 
     shebang.__skip_doctest__ = os.name != "posix"
 
     async def _run_script(self, p, cell, to_close):
         """callback for running the script in the background"""
 
         p.stdin.write(cell)
         await p.stdin.drain()
         p.stdin.close()
         await p.stdin.wait_closed()
         await p.wait()
         # asyncio read pipes have no close
         # but we should drain the data anyway
         for s in to_close:
             await s.read()
         self._gc_bg_processes()
 
     @line_magic("killbgscripts")
     def killbgscripts(self, _nouse_=''):
         """Kill all BG processes started by %%script and its family."""
         self.kill_bg_processes()
         print("All background processes were killed.")
 
     def kill_bg_processes(self):
         """Kill all BG processes which are still running."""
         if not self.bg_processes:
             return
         for p in self.bg_processes:
             if p.returncode is None:
                 try:
                     p.send_signal(signal.SIGINT)
                 except:
                     pass
         time.sleep(0.1)
         self._gc_bg_processes()
         if not self.bg_processes:
             return
         for p in self.bg_processes:
             if p.returncode is None:
                 try:
                     p.terminate()
                 except:
                     pass
         time.sleep(0.1)
         self._gc_bg_processes()
         if not self.bg_processes:
             return
         for p in self.bg_processes:
             if p.returncode is None:
                 try:
                     p.kill()
                 except:
                     pass
         self._gc_bg_processes()
 
     def _gc_bg_processes(self):
         self.bg_processes = [p for p in self.bg_processes if p.returncode is None]

IPython/core/tests/test_inputtransformer2.py

@@ -1,442 +1,443 b''
 """Tests for the token-based transformers in IPython.core.inputtransformer2
 
 Line-based transformers are the simpler ones; token-based transformers are
 more complex. See test_inputtransformer2_line for tests for line-based
 transformations.
 """
 import platform
 import string
 import sys
 from textwrap import dedent
 
 import pytest
 
 from IPython.core import inputtransformer2 as ipt2
 from IPython.core.inputtransformer2 import _find_assign_op, make_tokens_by_line
 
 MULTILINE_MAGIC = (
     """\
 a = f()
 %foo \\
 bar
 g()
 """.splitlines(
         keepends=True
     ),
     (2, 0),
     """\
 a = f()
 get_ipython().run_line_magic('foo', ' bar')
 g()
 """.splitlines(
         keepends=True
     ),
 )
 
 INDENTED_MAGIC = (
     """\
 for a in range(5):
     %ls
 """.splitlines(
         keepends=True
     ),
     (2, 4),
     """\
 for a in range(5):
     get_ipython().run_line_magic('ls', '')
 """.splitlines(
         keepends=True
     ),
 )
 
 CRLF_MAGIC = (
     ["a = f()\n", "%ls\r\n", "g()\n"],
     (2, 0),
     ["a = f()\n", "get_ipython().run_line_magic('ls', '')\n", "g()\n"],
 )
 
 MULTILINE_MAGIC_ASSIGN = (
     """\
 a = f()
 b = %foo \\
   bar
 g()
 """.splitlines(
         keepends=True
     ),
     (2, 4),
     """\
 a = f()
 b = get_ipython().run_line_magic('foo', '   bar')
 g()
 """.splitlines(
         keepends=True
     ),
 )
 
 MULTILINE_SYSTEM_ASSIGN = ("""\
 a = f()
 b = !foo \\
   bar
 g()
 """.splitlines(keepends=True), (2, 4), """\
 a = f()
 b = get_ipython().getoutput('foo    bar')
 g()
 """.splitlines(keepends=True))
 
 #####
 
-MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT = ("""\
+MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT = (
+    """\
 def test():
   for i in range(1):
     print(i)
   res =! ls
 """.splitlines(
         keepends=True
     ),
     (4, 7),
     """\
 def test():
   for i in range(1):
     print(i)
   res =get_ipython().getoutput(\' ls\')
 """.splitlines(
         keepends=True
     ),
 )
 
 ######
 
 AUTOCALL_QUOTE = ([",f 1 2 3\n"], (1, 0), ['f("1", "2", "3")\n'])
 
 AUTOCALL_QUOTE2 = ([";f 1 2 3\n"], (1, 0), ['f("1 2 3")\n'])
 
 AUTOCALL_PAREN = (["/f 1 2 3\n"], (1, 0), ["f(1, 2, 3)\n"])
 
 SIMPLE_HELP = (["foo?\n"], (1, 0), ["get_ipython().run_line_magic('pinfo', 'foo')\n"])
 
 DETAILED_HELP = (
     ["foo??\n"],
     (1, 0),
     ["get_ipython().run_line_magic('pinfo2', 'foo')\n"],
 )
 
 MAGIC_HELP = (["%foo?\n"], (1, 0), ["get_ipython().run_line_magic('pinfo', '%foo')\n"])
 
 HELP_IN_EXPR = (
     ["a = b + c?\n"],
     (1, 0),
     ["get_ipython().run_line_magic('pinfo', 'c')\n"],
 )
 
 HELP_CONTINUED_LINE = (
     """\
 a = \\
 zip?
 """.splitlines(
         keepends=True
     ),
     (1, 0),
     [r"get_ipython().run_line_magic('pinfo', 'zip')" + "\n"],
 )
 
 HELP_MULTILINE = (
     """\
 (a,
 b) = zip?
 """.splitlines(
         keepends=True
     ),
     (1, 0),
     [r"get_ipython().run_line_magic('pinfo', 'zip')" + "\n"],
 )
 
 HELP_UNICODE = (
     ["π.foo?\n"],
     (1, 0),
     ["get_ipython().run_line_magic('pinfo', 'π.foo')\n"],
 )
 
 
 def null_cleanup_transformer(lines):
     """
     A cleanup transform that returns an empty list.
     """
     return []
 
 
 def test_check_make_token_by_line_never_ends_empty():
     """
     Check that not sequence of single or double characters ends up leading to en empty list of tokens
     """
     from string import printable
 
     for c in printable:
         assert make_tokens_by_line(c)[-1] != []
         for k in printable:
             assert make_tokens_by_line(c + k)[-1] != []
 
 
 def check_find(transformer, case, match=True):
     sample, expected_start, _ = case
     tbl = make_tokens_by_line(sample)
     res = transformer.find(tbl)
     if match:
         # start_line is stored 0-indexed, expected values are 1-indexed
         assert (res.start_line + 1, res.start_col) == expected_start
         return res
     else:
         assert res is None
 
 
 def check_transform(transformer_cls, case):
     lines, start, expected = case
     transformer = transformer_cls(start)
     assert transformer.transform(lines) == expected
 
 
 def test_continued_line():
     lines = MULTILINE_MAGIC_ASSIGN[0]
     assert ipt2.find_end_of_continued_line(lines, 1) == 2
 
     assert ipt2.assemble_continued_line(lines, (1, 5), 2) == "foo    bar"
 
 
 def test_find_assign_magic():
     check_find(ipt2.MagicAssign, MULTILINE_MAGIC_ASSIGN)
     check_find(ipt2.MagicAssign, MULTILINE_SYSTEM_ASSIGN, match=False)
     check_find(ipt2.MagicAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT, match=False)
 
 
 def test_transform_assign_magic():
     check_transform(ipt2.MagicAssign, MULTILINE_MAGIC_ASSIGN)
 
 
 def test_find_assign_system():
     check_find(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN)
     check_find(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT)
     check_find(ipt2.SystemAssign, (["a =  !ls\n"], (1, 5), None))
     check_find(ipt2.SystemAssign, (["a=!ls\n"], (1, 2), None))
     check_find(ipt2.SystemAssign, MULTILINE_MAGIC_ASSIGN, match=False)
 
 
 def test_transform_assign_system():
     check_transform(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN)
     check_transform(ipt2.SystemAssign, MULTILINE_SYSTEM_ASSIGN_AFTER_DEDENT)
 
 
 def test_find_magic_escape():
     check_find(ipt2.EscapedCommand, MULTILINE_MAGIC)
     check_find(ipt2.EscapedCommand, INDENTED_MAGIC)
     check_find(ipt2.EscapedCommand, MULTILINE_MAGIC_ASSIGN, match=False)
 
 
 def test_transform_magic_escape():
     check_transform(ipt2.EscapedCommand, MULTILINE_MAGIC)
     check_transform(ipt2.EscapedCommand, INDENTED_MAGIC)
     check_transform(ipt2.EscapedCommand, CRLF_MAGIC)
 
 
 def test_find_autocalls():
     for case in [AUTOCALL_QUOTE, AUTOCALL_QUOTE2, AUTOCALL_PAREN]:
         print("Testing %r" % case[0])
         check_find(ipt2.EscapedCommand, case)
 
 
 def test_transform_autocall():
     for case in [AUTOCALL_QUOTE, AUTOCALL_QUOTE2, AUTOCALL_PAREN]:
         print("Testing %r" % case[0])
         check_transform(ipt2.EscapedCommand, case)
 
 
 def test_find_help():
     for case in [SIMPLE_HELP, DETAILED_HELP, MAGIC_HELP, HELP_IN_EXPR]:
         check_find(ipt2.HelpEnd, case)
 
     tf = check_find(ipt2.HelpEnd, HELP_CONTINUED_LINE)
     assert tf.q_line == 1
     assert tf.q_col == 3
 
     tf = check_find(ipt2.HelpEnd, HELP_MULTILINE)
     assert tf.q_line == 1
     assert tf.q_col == 8
 
     # ? in a comment does not trigger help
     check_find(ipt2.HelpEnd, (["foo # bar?\n"], None, None), match=False)
     # Nor in a string
     check_find(ipt2.HelpEnd, (["foo = '''bar?\n"], None, None), match=False)
 
 
 def test_transform_help():
     tf = ipt2.HelpEnd((1, 0), (1, 9))
     assert tf.transform(HELP_IN_EXPR[0]) == HELP_IN_EXPR[2]
 
     tf = ipt2.HelpEnd((1, 0), (2, 3))
     assert tf.transform(HELP_CONTINUED_LINE[0]) == HELP_CONTINUED_LINE[2]
 
     tf = ipt2.HelpEnd((1, 0), (2, 8))
     assert tf.transform(HELP_MULTILINE[0]) == HELP_MULTILINE[2]
 
     tf = ipt2.HelpEnd((1, 0), (1, 0))
     assert tf.transform(HELP_UNICODE[0]) == HELP_UNICODE[2]
 
 
 def test_find_assign_op_dedent():
     """
     be careful that empty token like dedent are not counted as parens
     """
 
     class Tk:
         def __init__(self, s):
             self.string = s
 
     assert _find_assign_op([Tk(s) for s in ("", "a", "=", "b")]) == 2
     assert (
         _find_assign_op([Tk(s) for s in ("", "(", "a", "=", "b", ")", "=", "5")]) == 6
     )
 
 
 examples = [
     pytest.param("a = 1", "complete", None),
     pytest.param("for a in range(5):", "incomplete", 4),
     pytest.param("for a in range(5):\n    if a > 0:", "incomplete", 8),
     pytest.param("raise = 2", "invalid", None),
     pytest.param("a = [1,\n2,", "incomplete", 0),
     pytest.param("(\n))", "incomplete", 0),
     pytest.param("\\\r\n", "incomplete", 0),
     pytest.param("a = '''\n   hi", "incomplete", 3),
     pytest.param("def a():\n x=1\n global x", "invalid", None),
     pytest.param(
         "a \\ ",
         "invalid",
         None,
         marks=pytest.mark.xfail(
             reason="Bug in python 3.9.8 – bpo 45738",
             condition=sys.version_info
             in [(3, 9, 8, "final", 0), (3, 11, 0, "alpha", 2)],
             raises=SystemError,
             strict=True,
         ),
     ),  # Nothing allowed after backslash,
     pytest.param("1\\\n+2", "complete", None),
 ]
 
 
 @pytest.mark.parametrize("code, expected, number", examples)
 def test_check_complete_param(code, expected, number):
     cc = ipt2.TransformerManager().check_complete
     assert cc(code) == (expected, number)
 
 
 @pytest.mark.xfail(platform.python_implementation() == "PyPy", reason="fail on pypy")
 @pytest.mark.xfail(
     reason="Bug in python 3.9.8 – bpo 45738",
     condition=sys.version_info in [(3, 9, 8, "final", 0), (3, 11, 0, "alpha", 2)],
     raises=SystemError,
     strict=True,
 )
 def test_check_complete():
     cc = ipt2.TransformerManager().check_complete
 
     example = dedent(
         """
         if True:
             a=1"""
     )
 
     assert cc(example) == ("incomplete", 4)
     assert cc(example + "\n") == ("complete", None)
     assert cc(example + "\n    ") == ("complete", None)
 
     # no need to loop on all the letters/numbers.
     short = "12abAB" + string.printable[62:]
     for c in short:
         # test does not raise:
         cc(c)
         for k in short:
             cc(c + k)
 
     assert cc("def f():\n  x=0\n  \\\n  ") == ("incomplete", 2)
 
 
 @pytest.mark.xfail(platform.python_implementation() == "PyPy", reason="fail on pypy")
 @pytest.mark.parametrize(
     "value, expected",
     [
         ('''def foo():\n    """''', ("incomplete", 4)),
         ("""async with example:\n    pass""", ("incomplete", 4)),
         ("""async with example:\n    pass\n    """, ("complete", None)),
     ],
 )
 def test_check_complete_II(value, expected):
     """
     Test that multiple line strings are properly handled.
 
     Separate test function for convenience
 
     """
     cc = ipt2.TransformerManager().check_complete
     assert cc(value) == expected
 
 
 @pytest.mark.parametrize(
     "value, expected",
     [
         (")", ("invalid", None)),
         ("]", ("invalid", None)),
         ("}", ("invalid", None)),
         (")(", ("invalid", None)),
         ("][", ("invalid", None)),
         ("}{", ("invalid", None)),
         ("]()(", ("invalid", None)),
         ("())(", ("invalid", None)),
         (")[](", ("invalid", None)),
         ("()](", ("invalid", None)),
     ],
 )
 def test_check_complete_invalidates_sunken_brackets(value, expected):
     """
     Test that a single line with more closing brackets than the opening ones is
     interpreted as invalid
     """
     cc = ipt2.TransformerManager().check_complete
     assert cc(value) == expected
 
 
 def test_null_cleanup_transformer():
     manager = ipt2.TransformerManager()
     manager.cleanup_transforms.insert(0, null_cleanup_transformer)
     assert manager.transform_cell("") == ""
 
 
 def test_side_effects_I():
     count = 0
 
     def counter(lines):
         nonlocal count
         count += 1
         return lines
 
     counter.has_side_effects = True
 
     manager = ipt2.TransformerManager()
     manager.cleanup_transforms.insert(0, counter)
     assert manager.check_complete("a=1\n") == ("complete", None)
     assert count == 0
 
 
 def test_side_effects_II():
     count = 0
 
     def counter(lines):
         nonlocal count
         count += 1
         return lines
 
     counter.has_side_effects = True
 
     manager = ipt2.TransformerManager()
     manager.line_transforms.insert(0, counter)
     assert manager.check_complete("b=1\n") == ("complete", None)
     assert count == 0

IPython/core/tests/test_interactiveshell.py

@@ -1,1100 +1,1100 b''
 # -*- coding: utf-8 -*-
 """Tests for the key interactiveshell module.
 
 Historically the main classes in interactiveshell have been under-tested.  This
 module should grow as many single-method tests as possible to trap many of the
 recurring bugs we seem to encounter with high-level interaction.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import asyncio
 import ast
 import os
 import signal
 import shutil
 import sys
 import tempfile
 import unittest
 from unittest import mock
 
 from os.path import join
 
 from IPython.core.error import InputRejected
 from IPython.core.inputtransformer import InputTransformer
 from IPython.core import interactiveshell
 from IPython.testing.decorators import (
     skipif, skip_win32, onlyif_unicode_paths, onlyif_cmds_exist,
 )
 from IPython.testing import tools as tt
 from IPython.utils.process import find_cmd
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 # This is used by every single test, no point repeating it ad nauseam
 
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
 
 class DerivedInterrupt(KeyboardInterrupt):
     pass
 
 class InteractiveShellTestCase(unittest.TestCase):
     def test_naked_string_cells(self):
         """Test that cells with only naked strings are fully executed"""
         # First, single-line inputs
         ip.run_cell('"a"\n')
         self.assertEqual(ip.user_ns['_'], 'a')
         # And also multi-line cells
         ip.run_cell('"""a\nb"""\n')
         self.assertEqual(ip.user_ns['_'], 'a\nb')
 
     def test_run_empty_cell(self):
         """Just make sure we don't get a horrible error with a blank
         cell of input. Yes, I did overlook that."""
         old_xc = ip.execution_count
         res = ip.run_cell('')
         self.assertEqual(ip.execution_count, old_xc)
         self.assertEqual(res.execution_count, None)
 
     def test_run_cell_multiline(self):
         """Multi-block, multi-line cells must execute correctly.
         """
         src = '\n'.join(["x=1",
                          "y=2",
                          "if 1:",
                          "    x += 1",
                          "    y += 1",])
         res = ip.run_cell(src)
         self.assertEqual(ip.user_ns['x'], 2)
         self.assertEqual(ip.user_ns['y'], 3)
         self.assertEqual(res.success, True)
         self.assertEqual(res.result, None)
 
     def test_multiline_string_cells(self):
         "Code sprinkled with multiline strings should execute (GH-306)"
         ip.run_cell('tmp=0')
         self.assertEqual(ip.user_ns['tmp'], 0)
         res = ip.run_cell('tmp=1;"""a\nb"""\n')
         self.assertEqual(ip.user_ns['tmp'], 1)
         self.assertEqual(res.success, True)
         self.assertEqual(res.result, "a\nb")
 
     def test_dont_cache_with_semicolon(self):
         "Ending a line with semicolon should not cache the returned object (GH-307)"
         oldlen = len(ip.user_ns['Out'])
         for cell in ['1;', '1;1;']:
             res = ip.run_cell(cell, store_history=True)
             newlen = len(ip.user_ns['Out'])
             self.assertEqual(oldlen, newlen)
             self.assertIsNone(res.result)
         i = 0
         #also test the default caching behavior
         for cell in ['1', '1;1']:
             ip.run_cell(cell, store_history=True)
             newlen = len(ip.user_ns['Out'])
             i += 1
             self.assertEqual(oldlen+i, newlen)
 
     def test_syntax_error(self):
         res = ip.run_cell("raise = 3")
         self.assertIsInstance(res.error_before_exec, SyntaxError)
 
     def test_In_variable(self):
         "Verify that In variable grows with user input (GH-284)"
         oldlen = len(ip.user_ns['In'])
         ip.run_cell('1;', store_history=True)
         newlen = len(ip.user_ns['In'])
         self.assertEqual(oldlen+1, newlen)
         self.assertEqual(ip.user_ns['In'][-1],'1;')
         
     def test_magic_names_in_string(self):
         ip.run_cell('a = """\n%exit\n"""')
         self.assertEqual(ip.user_ns['a'], '\n%exit\n')
     
     def test_trailing_newline(self):
         """test that running !(command) does not raise a SyntaxError"""
         ip.run_cell('!(true)\n', False)
         ip.run_cell('!(true)\n\n\n', False)
     
     def test_gh_597(self):
         """Pretty-printing lists of objects with non-ascii reprs may cause
         problems."""
         class Spam(object):
             def __repr__(self):
                 return "\xe9"*50
         import IPython.core.formatters
         f = IPython.core.formatters.PlainTextFormatter()
         f([Spam(),Spam()])
     
 
     def test_future_flags(self):
         """Check that future flags are used for parsing code (gh-777)"""
         ip.run_cell('from __future__ import barry_as_FLUFL')
         try:
             ip.run_cell('prfunc_return_val = 1 <> 2')
             assert 'prfunc_return_val' in ip.user_ns
         finally:
             # Reset compiler flags so we don't mess up other tests.
             ip.compile.reset_compiler_flags()
 
     def test_can_pickle(self):
         "Can we pickle objects defined interactively (GH-29)"
         ip = get_ipython()
         ip.reset()
         ip.run_cell(("class Mylist(list):\n"
                      "    def __init__(self,x=[]):\n"
                      "        list.__init__(self,x)"))
         ip.run_cell("w=Mylist([1,2,3])")
         
         from pickle import dumps
         
         # We need to swap in our main module - this is only necessary
         # inside the test framework, because IPython puts the interactive module
         # in place (but the test framework undoes this).
         _main = sys.modules['__main__']
         sys.modules['__main__'] = ip.user_module
         try:
             res = dumps(ip.user_ns["w"])
         finally:
             sys.modules['__main__'] = _main
         self.assertTrue(isinstance(res, bytes))
         
     def test_global_ns(self):
         "Code in functions must be able to access variables outside them."
         ip = get_ipython()
         ip.run_cell("a = 10")
         ip.run_cell(("def f(x):\n"
                      "    return x + a"))
         ip.run_cell("b = f(12)")
         self.assertEqual(ip.user_ns["b"], 22)
 
     def test_bad_custom_tb(self):
         """Check that InteractiveShell is protected from bad custom exception handlers"""
         ip.set_custom_exc((IOError,), lambda etype,value,tb: 1/0)
         self.assertEqual(ip.custom_exceptions, (IOError,))
         with tt.AssertPrints("Custom TB Handler failed", channel='stderr'):
             ip.run_cell(u'raise IOError("foo")')
         self.assertEqual(ip.custom_exceptions, ())
 
     def test_bad_custom_tb_return(self):
         """Check that InteractiveShell is protected from bad return types in custom exception handlers"""
         ip.set_custom_exc((NameError,),lambda etype,value,tb, tb_offset=None: 1)
         self.assertEqual(ip.custom_exceptions, (NameError,))
         with tt.AssertPrints("Custom TB Handler failed", channel='stderr'):
             ip.run_cell(u'a=abracadabra')
         self.assertEqual(ip.custom_exceptions, ())
 
     def test_drop_by_id(self):
         myvars = {"a":object(), "b":object(), "c": object()}
         ip.push(myvars, interactive=False)
         for name in myvars:
             assert name in ip.user_ns, name
             assert name in ip.user_ns_hidden, name
         ip.user_ns['b'] = 12
         ip.drop_by_id(myvars)
         for name in ["a", "c"]:
             assert name not in ip.user_ns, name
             assert name not in ip.user_ns_hidden, name
         assert ip.user_ns['b'] == 12
         ip.reset()
 
     def test_var_expand(self):
         ip.user_ns['f'] = u'Ca\xf1o'
         self.assertEqual(ip.var_expand(u'echo $f'), u'echo Ca\xf1o')
         self.assertEqual(ip.var_expand(u'echo {f}'), u'echo Ca\xf1o')
         self.assertEqual(ip.var_expand(u'echo {f[:-1]}'), u'echo Ca\xf1')
         self.assertEqual(ip.var_expand(u'echo {1*2}'), u'echo 2')
         
         self.assertEqual(ip.var_expand(u"grep x | awk '{print $1}'"), u"grep x | awk '{print $1}'")
 
         ip.user_ns['f'] = b'Ca\xc3\xb1o'
         # This should not raise any exception:
         ip.var_expand(u'echo $f')
    
     def test_var_expand_local(self):
         """Test local variable expansion in !system and %magic calls"""
         # !system
         ip.run_cell(
             "def test():\n"
             '    lvar = "ttt"\n'
             "    ret = !echo {lvar}\n"
             "    return ret[0]\n"
         )
         res = ip.user_ns["test"]()
         self.assertIn("ttt", res)
 
         # %magic
         ip.run_cell(
             "def makemacro():\n"
             '    macroname = "macro_var_expand_locals"\n'
             "    %macro {macroname} codestr\n"
         )
         ip.user_ns["codestr"] = "str(12)"
         ip.run_cell("makemacro()")
         self.assertIn("macro_var_expand_locals", ip.user_ns)
 
     def test_var_expand_self(self):
         """Test variable expansion with the name 'self', which was failing.
         
         See https://github.com/ipython/ipython/issues/1878#issuecomment-7698218
         """
         ip.run_cell(
             "class cTest:\n"
             '  classvar="see me"\n'
             "  def test(self):\n"
             "    res = !echo Variable: {self.classvar}\n"
             "    return res[0]\n"
         )
         self.assertIn("see me", ip.user_ns["cTest"]().test())
 
     def test_bad_var_expand(self):
         """var_expand on invalid formats shouldn't raise"""
         # SyntaxError
         self.assertEqual(ip.var_expand(u"{'a':5}"), u"{'a':5}")
         # NameError
         self.assertEqual(ip.var_expand(u"{asdf}"), u"{asdf}")
         # ZeroDivisionError
         self.assertEqual(ip.var_expand(u"{1/0}"), u"{1/0}")
     
     def test_silent_postexec(self):
         """run_cell(silent=True) doesn't invoke pre/post_run_cell callbacks"""
         pre_explicit = mock.Mock()
         pre_always = mock.Mock()
         post_explicit = mock.Mock()
         post_always = mock.Mock()
         all_mocks = [pre_explicit, pre_always, post_explicit, post_always]
         
         ip.events.register('pre_run_cell', pre_explicit)
         ip.events.register('pre_execute', pre_always)
         ip.events.register('post_run_cell', post_explicit)
         ip.events.register('post_execute', post_always)
         
         try:
             ip.run_cell("1", silent=True)
             assert pre_always.called
             assert not pre_explicit.called
             assert post_always.called
             assert not post_explicit.called
             # double-check that non-silent exec did what we expected
             # silent to avoid
             ip.run_cell("1")
             assert pre_explicit.called
             assert post_explicit.called
             info, = pre_explicit.call_args[0]
             result, = post_explicit.call_args[0]
             self.assertEqual(info, result.info)
             # check that post hooks are always called
             [m.reset_mock() for m in all_mocks]
             ip.run_cell("syntax error")
             assert pre_always.called
             assert pre_explicit.called
             assert post_always.called
             assert post_explicit.called
             info, = pre_explicit.call_args[0]
             result, = post_explicit.call_args[0]
             self.assertEqual(info, result.info)
         finally:
             # remove post-exec
             ip.events.unregister('pre_run_cell', pre_explicit)
             ip.events.unregister('pre_execute', pre_always)
             ip.events.unregister('post_run_cell', post_explicit)
             ip.events.unregister('post_execute', post_always)
     
     def test_silent_noadvance(self):
         """run_cell(silent=True) doesn't advance execution_count"""
         ec = ip.execution_count
         # silent should force store_history=False
         ip.run_cell("1", store_history=True, silent=True)
         
         self.assertEqual(ec, ip.execution_count)
         # double-check that non-silent exec did what we expected
         # silent to avoid
         ip.run_cell("1", store_history=True)
         self.assertEqual(ec+1, ip.execution_count)
     
     def test_silent_nodisplayhook(self):
         """run_cell(silent=True) doesn't trigger displayhook"""
         d = dict(called=False)
         
         trap = ip.display_trap
         save_hook = trap.hook
         
         def failing_hook(*args, **kwargs):
             d['called'] = True
         
         try:
             trap.hook = failing_hook
             res = ip.run_cell("1", silent=True)
             self.assertFalse(d['called'])
             self.assertIsNone(res.result)
             # double-check that non-silent exec did what we expected
             # silent to avoid
             ip.run_cell("1")
             self.assertTrue(d['called'])
         finally:
             trap.hook = save_hook
 
     def test_ofind_line_magic(self):
         from IPython.core.magic import register_line_magic
         
         @register_line_magic
         def lmagic(line):
             "A line magic"
 
         # Get info on line magic
         lfind = ip._ofind("lmagic")
         info = dict(
             found=True,
             isalias=False,
             ismagic=True,
             namespace="IPython internal",
             obj=lmagic,
             parent=None,
         )
         self.assertEqual(lfind, info)
         
     def test_ofind_cell_magic(self):
         from IPython.core.magic import register_cell_magic
         
         @register_cell_magic
         def cmagic(line, cell):
             "A cell magic"
 
         # Get info on cell magic
         find = ip._ofind("cmagic")
         info = dict(
             found=True,
             isalias=False,
             ismagic=True,
             namespace="IPython internal",
             obj=cmagic,
             parent=None,
         )
         self.assertEqual(find, info)
 
     def test_ofind_property_with_error(self):
         class A(object):
             @property
             def foo(self):
                 raise NotImplementedError()  # pragma: no cover
 
         a = A()
 
         found = ip._ofind('a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=A.foo, parent=a)
         self.assertEqual(found, info)
 
     def test_ofind_multiple_attribute_lookups(self):
         class A(object):
             @property
             def foo(self):
                 raise NotImplementedError()  # pragma: no cover
 
         a = A()
         a.a = A()
         a.a.a = A()
 
         found = ip._ofind('a.a.a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=A.foo, parent=a.a.a)
         self.assertEqual(found, info)
 
     def test_ofind_slotted_attributes(self):
         class A(object):
             __slots__ = ['foo']
             def __init__(self):
                 self.foo = 'bar'
 
         a = A()
         found = ip._ofind('a.foo', [('locals', locals())])
         info = dict(found=True, isalias=False, ismagic=False,
                     namespace='locals', obj=a.foo, parent=a)
         self.assertEqual(found, info)
 
         found = ip._ofind('a.bar', [('locals', locals())])
         info = dict(found=False, isalias=False, ismagic=False,
                     namespace=None, obj=None, parent=a)
         self.assertEqual(found, info)
 
     def test_ofind_prefers_property_to_instance_level_attribute(self):
         class A(object):
             @property
             def foo(self):
                 return 'bar'
         a = A()
         a.__dict__["foo"] = "baz"
         self.assertEqual(a.foo, "bar")
         found = ip._ofind("a.foo", [("locals", locals())])
         self.assertIs(found["obj"], A.foo)
 
     def test_custom_syntaxerror_exception(self):
         called = []
         def my_handler(shell, etype, value, tb, tb_offset=None):
             called.append(etype)
             shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
 
         ip.set_custom_exc((SyntaxError,), my_handler)
         try:
             ip.run_cell("1f")
             # Check that this was called, and only once.
             self.assertEqual(called, [SyntaxError])
         finally:
             # Reset the custom exception hook
             ip.set_custom_exc((), None)
 
     def test_custom_exception(self):
         called = []
         def my_handler(shell, etype, value, tb, tb_offset=None):
             called.append(etype)
             shell.showtraceback((etype, value, tb), tb_offset=tb_offset)
         
         ip.set_custom_exc((ValueError,), my_handler)
         try:
             res = ip.run_cell("raise ValueError('test')")
             # Check that this was called, and only once.
             self.assertEqual(called, [ValueError])
             # Check that the error is on the result object
             self.assertIsInstance(res.error_in_exec, ValueError)
         finally:
             # Reset the custom exception hook
             ip.set_custom_exc((), None)
     
     @mock.patch("builtins.print")
     def test_showtraceback_with_surrogates(self, mocked_print):
         values = []
 
         def mock_print_func(value, sep=" ", end="\n", file=sys.stdout, flush=False):
             values.append(value)
             if value == chr(0xD8FF):
                 raise UnicodeEncodeError("utf-8", chr(0xD8FF), 0, 1, "")
 
         # mock builtins.print
         mocked_print.side_effect = mock_print_func
 
         # ip._showtraceback() is replaced in globalipapp.py.
         # Call original method to test.
         interactiveshell.InteractiveShell._showtraceback(ip, None, None, chr(0xD8FF))
 
         self.assertEqual(mocked_print.call_count, 2)
         self.assertEqual(values, [chr(0xD8FF), "\\ud8ff"])
 
     def test_mktempfile(self):
         filename = ip.mktempfile()
         # Check that we can open the file again on Windows
         with open(filename, "w", encoding="utf-8") as f:
             f.write("abc")
 
         filename = ip.mktempfile(data="blah")
         with open(filename, "r", encoding="utf-8") as f:
             self.assertEqual(f.read(), "blah")
 
     def test_new_main_mod(self):
         # Smoketest to check that this accepts a unicode module name
         name = u'jiefmw'
         mod = ip.new_main_mod(u'%s.py' % name, name)
         self.assertEqual(mod.__name__, name)
 
     def test_get_exception_only(self):
         try:
             raise KeyboardInterrupt
         except KeyboardInterrupt:
             msg = ip.get_exception_only()
         self.assertEqual(msg, 'KeyboardInterrupt\n')
 
         try:
             raise DerivedInterrupt("foo")
         except KeyboardInterrupt:
             msg = ip.get_exception_only()
         self.assertEqual(msg, 'IPython.core.tests.test_interactiveshell.DerivedInterrupt: foo\n')
 
     def test_inspect_text(self):
         ip.run_cell('a = 5')
         text = ip.object_inspect_text('a')
         self.assertIsInstance(text, str)
 
     def test_last_execution_result(self):
         """ Check that last execution result gets set correctly (GH-10702) """
         result = ip.run_cell('a = 5; a')
         self.assertTrue(ip.last_execution_succeeded)
         self.assertEqual(ip.last_execution_result.result, 5)
 
         result = ip.run_cell('a = x_invalid_id_x')
         self.assertFalse(ip.last_execution_succeeded)
         self.assertFalse(ip.last_execution_result.success)
         self.assertIsInstance(ip.last_execution_result.error_in_exec, NameError)
 
     def test_reset_aliasing(self):
         """ Check that standard posix aliases work after %reset. """
         if os.name != 'posix':
             return
 
         ip.reset()
         for cmd in ('clear', 'more', 'less', 'man'):
             res = ip.run_cell('%' + cmd)
             self.assertEqual(res.success, True)
 
 
 class TestSafeExecfileNonAsciiPath(unittest.TestCase):
 
     @onlyif_unicode_paths
     def setUp(self):
         self.BASETESTDIR = tempfile.mkdtemp()
         self.TESTDIR = join(self.BASETESTDIR, u"åäö")
         os.mkdir(self.TESTDIR)
         with open(
-            join(self.TESTDIR, u"åäötestscript.py"), "w", encoding="utf-8"
+            join(self.TESTDIR, "åäötestscript.py"), "w", encoding="utf-8"
         ) as sfile:
             sfile.write("pass\n")
         self.oldpath = os.getcwd()
         os.chdir(self.TESTDIR)
         self.fname = u"åäötestscript.py"
 
     def tearDown(self):
         os.chdir(self.oldpath)
         shutil.rmtree(self.BASETESTDIR)
 
     @onlyif_unicode_paths
     def test_1(self):
         """Test safe_execfile with non-ascii path
         """
         ip.safe_execfile(self.fname, {}, raise_exceptions=True)
 
 class ExitCodeChecks(tt.TempFileMixin):
 
     def setUp(self):
         self.system = ip.system_raw
 
     def test_exit_code_ok(self):
         self.system('exit 0')
         self.assertEqual(ip.user_ns['_exit_code'], 0)
 
     def test_exit_code_error(self):
         self.system('exit 1')
         self.assertEqual(ip.user_ns['_exit_code'], 1)
     
     @skipif(not hasattr(signal, 'SIGALRM'))
     def test_exit_code_signal(self):
         self.mktmp("import signal, time\n"
                    "signal.setitimer(signal.ITIMER_REAL, 0.1)\n"
                    "time.sleep(1)\n")
         self.system("%s %s" % (sys.executable, self.fname))
         self.assertEqual(ip.user_ns['_exit_code'], -signal.SIGALRM)
     
     @onlyif_cmds_exist("csh")
     def test_exit_code_signal_csh(self):  # pragma: no cover
         SHELL = os.environ.get("SHELL", None)
         os.environ["SHELL"] = find_cmd("csh")
         try:
             self.test_exit_code_signal()
         finally:
             if SHELL is not None:
                 os.environ['SHELL'] = SHELL
             else:
                 del os.environ['SHELL']
 
 
 class TestSystemRaw(ExitCodeChecks):
 
     def setUp(self):
         super().setUp()
         self.system = ip.system_raw
 
     @onlyif_unicode_paths
     def test_1(self):
         """Test system_raw with non-ascii cmd
         """
         cmd = u'''python -c "'åäö'"   '''
         ip.system_raw(cmd)
 
     @mock.patch('subprocess.call', side_effect=KeyboardInterrupt)
     @mock.patch('os.system', side_effect=KeyboardInterrupt)
     def test_control_c(self, *mocks):
         try:
             self.system("sleep 1 # wont happen")
         except KeyboardInterrupt:  # pragma: no cove
             self.fail(
                 "system call should intercept "
                 "keyboard interrupt from subprocess.call"
             )
         self.assertEqual(ip.user_ns["_exit_code"], -signal.SIGINT)
 
     def test_magic_warnings(self):
         for magic_cmd in ("pip", "conda", "cd"):
             with self.assertWarnsRegex(Warning, "You executed the system command"):
                 ip.system_raw(magic_cmd)
 
 # TODO: Exit codes are currently ignored on Windows.
 class TestSystemPipedExitCode(ExitCodeChecks):
 
     def setUp(self):
         super().setUp()
         self.system = ip.system_piped
 
     @skip_win32
     def test_exit_code_ok(self):
         ExitCodeChecks.test_exit_code_ok(self)
 
     @skip_win32
     def test_exit_code_error(self):
         ExitCodeChecks.test_exit_code_error(self)
 
     @skip_win32
     def test_exit_code_signal(self):
         ExitCodeChecks.test_exit_code_signal(self)
 
 class TestModules(tt.TempFileMixin):
     def test_extraneous_loads(self):
         """Test we're not loading modules on startup that we shouldn't.
         """
         self.mktmp("import sys\n"
                    "print('numpy' in sys.modules)\n"
                    "print('ipyparallel' in sys.modules)\n"
                    "print('ipykernel' in sys.modules)\n"
                    )
         out = "False\nFalse\nFalse\n"
         tt.ipexec_validate(self.fname, out)
 
 class Negator(ast.NodeTransformer):
     """Negates all number literals in an AST."""
 
     # for python 3.7 and earlier
     def visit_Num(self, node):
         node.n = -node.n
         return node
 
     # for python 3.8+
     def visit_Constant(self, node):
         if isinstance(node.value, int):
             return self.visit_Num(node)
         return node
 
 class TestAstTransform(unittest.TestCase):
     def setUp(self):
         self.negator = Negator()
         ip.ast_transformers.append(self.negator)
     
     def tearDown(self):
         ip.ast_transformers.remove(self.negator)
 
     def test_non_int_const(self):
         with tt.AssertPrints("hello"):
             ip.run_cell('print("hello")')
 
     def test_run_cell(self):
         with tt.AssertPrints("-34"):
             ip.run_cell("print(12 + 22)")
 
         # A named reference to a number shouldn't be transformed.
         ip.user_ns["n"] = 55
         with tt.AssertNotPrints("-55"):
             ip.run_cell("print(n)")
 
     def test_timeit(self):
         called = set()
         def f(x):
             called.add(x)
         ip.push({'f':f})
         
         with tt.AssertPrints("std. dev. of"):
             ip.run_line_magic("timeit", "-n1 f(1)")
         self.assertEqual(called, {-1})
         called.clear()
 
         with tt.AssertPrints("std. dev. of"):
             ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
         self.assertEqual(called, {-2, -3})
     
     def test_time(self):
         called = []
         def f(x):
             called.append(x)
         ip.push({'f':f})
         
         # Test with an expression
         with tt.AssertPrints("Wall time: "):
             ip.run_line_magic("time", "f(5+9)")
         self.assertEqual(called, [-14])
         called[:] = []
         
         # Test with a statement (different code path)
         with tt.AssertPrints("Wall time: "):
             ip.run_line_magic("time", "a = f(-3 + -2)")
         self.assertEqual(called, [5])
     
     def test_macro(self):
         ip.push({'a':10})
         # The AST transformation makes this do a+=-1
         ip.define_macro("amacro", "a+=1\nprint(a)")
         
         with tt.AssertPrints("9"):
             ip.run_cell("amacro")
         with tt.AssertPrints("8"):
             ip.run_cell("amacro")
 
 class TestMiscTransform(unittest.TestCase):
 
 
     def test_transform_only_once(self):
         cleanup = 0
         line_t = 0
         def count_cleanup(lines):
             nonlocal cleanup
             cleanup += 1
             return lines
 
         def count_line_t(lines):
             nonlocal line_t
             line_t += 1
             return lines
 
         ip.input_transformer_manager.cleanup_transforms.append(count_cleanup)
         ip.input_transformer_manager.line_transforms.append(count_line_t)
 
         ip.run_cell('1')
 
         assert cleanup == 1
         assert line_t == 1
 
 class IntegerWrapper(ast.NodeTransformer):
     """Wraps all integers in a call to Integer()"""
 
     # for Python 3.7 and earlier
 
     # for Python 3.7 and earlier
     def visit_Num(self, node):
         if isinstance(node.n, int):
             return ast.Call(func=ast.Name(id='Integer', ctx=ast.Load()),
                             args=[node], keywords=[])
         return node
 
     # For Python 3.8+
     def visit_Constant(self, node):
         if isinstance(node.value, int):
             return self.visit_Num(node)
         return node
 
 
 class TestAstTransform2(unittest.TestCase):
     def setUp(self):
         self.intwrapper = IntegerWrapper()
         ip.ast_transformers.append(self.intwrapper)
         
         self.calls = []
         def Integer(*args):
             self.calls.append(args)
             return args
         ip.push({"Integer": Integer})
     
     def tearDown(self):
         ip.ast_transformers.remove(self.intwrapper)
         del ip.user_ns['Integer']
     
     def test_run_cell(self):
         ip.run_cell("n = 2")
         self.assertEqual(self.calls, [(2,)])
         
         # This shouldn't throw an error
         ip.run_cell("o = 2.0")
         self.assertEqual(ip.user_ns['o'], 2.0)
 
     def test_run_cell_non_int(self):
         ip.run_cell("n = 'a'")
         assert self.calls == []
 
     def test_timeit(self):
         called = set()
         def f(x):
             called.add(x)
         ip.push({'f':f})
 
         with tt.AssertPrints("std. dev. of"):
             ip.run_line_magic("timeit", "-n1 f(1)")
         self.assertEqual(called, {(1,)})
         called.clear()
 
         with tt.AssertPrints("std. dev. of"):
             ip.run_cell_magic("timeit", "-n1 f(2)", "f(3)")
         self.assertEqual(called, {(2,), (3,)})
 
 class ErrorTransformer(ast.NodeTransformer):
     """Throws an error when it sees a number."""
 
     def visit_Constant(self, node):
         if isinstance(node.value, int):
             raise ValueError("test")
         return node
 
 
 class TestAstTransformError(unittest.TestCase):
     def test_unregistering(self):
         err_transformer = ErrorTransformer()
         ip.ast_transformers.append(err_transformer)
         
         with self.assertWarnsRegex(UserWarning, "It will be unregistered"):
             ip.run_cell("1 + 2")
         
         # This should have been removed.
         self.assertNotIn(err_transformer, ip.ast_transformers)
 
 
 class StringRejector(ast.NodeTransformer):
     """Throws an InputRejected when it sees a string literal.
 
     Used to verify that NodeTransformers can signal that a piece of code should
     not be executed by throwing an InputRejected.
     """
     
     # 3.8 only
     def visit_Constant(self, node):
         if isinstance(node.value, str):
             raise InputRejected("test")
         return node
 
 
 class TestAstTransformInputRejection(unittest.TestCase):
 
     def setUp(self):
         self.transformer = StringRejector()
         ip.ast_transformers.append(self.transformer)
 
     def tearDown(self):
         ip.ast_transformers.remove(self.transformer)
 
     def test_input_rejection(self):
         """Check that NodeTransformers can reject input."""
 
         expect_exception_tb = tt.AssertPrints("InputRejected: test")
         expect_no_cell_output = tt.AssertNotPrints("'unsafe'", suppress=False)
 
         # Run the same check twice to verify that the transformer is not
         # disabled after raising.
         with expect_exception_tb, expect_no_cell_output:
             ip.run_cell("'unsafe'")
 
         with expect_exception_tb, expect_no_cell_output:
             res = ip.run_cell("'unsafe'")
 
         self.assertIsInstance(res.error_before_exec, InputRejected)
 
 def test__IPYTHON__():
     # This shouldn't raise a NameError, that's all
     __IPYTHON__
 
 
 class DummyRepr(object):
     def __repr__(self):
         return "DummyRepr"
     
     def _repr_html_(self):
         return "<b>dummy</b>"
     
     def _repr_javascript_(self):
         return "console.log('hi');", {'key': 'value'}
     
 
 def test_user_variables():
     # enable all formatters
     ip.display_formatter.active_types = ip.display_formatter.format_types
     
     ip.user_ns['dummy'] = d = DummyRepr()
     keys = {'dummy', 'doesnotexist'}
     r = ip.user_expressions({ key:key for key in keys})
 
     assert keys == set(r.keys())
     dummy = r["dummy"]
     assert {"status", "data", "metadata"} == set(dummy.keys())
     assert dummy["status"] == "ok"
     data = dummy["data"]
     metadata = dummy["metadata"]
     assert data.get("text/html") == d._repr_html_()
     js, jsmd = d._repr_javascript_()
     assert data.get("application/javascript") == js
     assert metadata.get("application/javascript") == jsmd
 
     dne = r["doesnotexist"]
     assert dne["status"] == "error"
     assert dne["ename"] == "NameError"
 
     # back to text only
     ip.display_formatter.active_types = ['text/plain']
     
 def test_user_expression():
     # enable all formatters
     ip.display_formatter.active_types = ip.display_formatter.format_types
     query = {
         'a' : '1 + 2',
         'b' : '1/0',
     }
     r = ip.user_expressions(query)
     import pprint
     pprint.pprint(r)
     assert set(r.keys()) == set(query.keys())
     a = r["a"]
     assert {"status", "data", "metadata"} == set(a.keys())
     assert a["status"] == "ok"
     data = a["data"]
     metadata = a["metadata"]
     assert data.get("text/plain") == "3"
 
     b = r["b"]
     assert b["status"] == "error"
     assert b["ename"] == "ZeroDivisionError"
 
     # back to text only
     ip.display_formatter.active_types = ['text/plain']
 
 
 class TestSyntaxErrorTransformer(unittest.TestCase):
     """Check that SyntaxError raised by an input transformer is handled by run_cell()"""
 
     @staticmethod
     def transformer(lines):
         for line in lines:
             pos = line.find('syntaxerror')
             if pos >= 0:
                 e = SyntaxError('input contains "syntaxerror"')
                 e.text = line
                 e.offset = pos + 1
                 raise e
         return lines
 
     def setUp(self):
         ip.input_transformers_post.append(self.transformer)
 
     def tearDown(self):
         ip.input_transformers_post.remove(self.transformer)
 
     def test_syntaxerror_input_transformer(self):
         with tt.AssertPrints('1234'):
             ip.run_cell('1234')
         with tt.AssertPrints('SyntaxError: invalid syntax'):
             ip.run_cell('1 2 3')   # plain python syntax error
         with tt.AssertPrints('SyntaxError: input contains "syntaxerror"'):
             ip.run_cell('2345  # syntaxerror')  # input transformer syntax error
         with tt.AssertPrints('3456'):
             ip.run_cell('3456')
 
 
 class TestWarningSuppression(unittest.TestCase):
     def test_warning_suppression(self):
         ip.run_cell("import warnings")
         try:
             with self.assertWarnsRegex(UserWarning, "asdf"):
                 ip.run_cell("warnings.warn('asdf')")
             # Here's the real test -- if we run that again, we should get the
             # warning again. Traditionally, each warning was only issued once per
             # IPython session (approximately), even if the user typed in new and
             # different code that should have also triggered the warning, leading
             # to much confusion.
             with self.assertWarnsRegex(UserWarning, "asdf"):
                 ip.run_cell("warnings.warn('asdf')")
         finally:
             ip.run_cell("del warnings")
 
 
     def test_deprecation_warning(self):
         ip.run_cell("""
 import warnings
 def wrn():
     warnings.warn(
         "I AM  A WARNING",
         DeprecationWarning
     )
         """)
         try:
             with self.assertWarnsRegex(DeprecationWarning, "I AM  A WARNING"):
                 ip.run_cell("wrn()")
         finally:
             ip.run_cell("del warnings")
             ip.run_cell("del wrn")
 
 
 class TestImportNoDeprecate(tt.TempFileMixin):
 
     def setUp(self):
         """Make a valid python temp file."""
         self.mktmp("""
 import warnings
 def wrn():
     warnings.warn(
         "I AM  A WARNING",
         DeprecationWarning
     )
 """)
         super().setUp()
 
     def test_no_dep(self):
         """
         No deprecation warning should be raised from imported functions
         """
         ip.run_cell("from {} import wrn".format(self.fname))
 
         with tt.AssertNotPrints("I AM  A WARNING"):
             ip.run_cell("wrn()")
         ip.run_cell("del wrn")
 
 
 def test_custom_exc_count():
     hook = mock.Mock(return_value=None)
     ip.set_custom_exc((SyntaxError,), hook)
     before = ip.execution_count
     ip.run_cell("def foo()", store_history=True)
     # restore default excepthook
     ip.set_custom_exc((), None)
     assert hook.call_count == 1
     assert ip.execution_count == before + 1
 
 
 def test_run_cell_async():
     ip.run_cell("import asyncio")
     coro = ip.run_cell_async("await asyncio.sleep(0.01)\n5")
     assert asyncio.iscoroutine(coro)
     loop = asyncio.new_event_loop()
     result = loop.run_until_complete(coro)
     assert isinstance(result, interactiveshell.ExecutionResult)
     assert result.result == 5
 
 
 def test_run_cell_await():
     ip.run_cell("import asyncio")
     result = ip.run_cell("await asyncio.sleep(0.01); 10")
     assert ip.user_ns["_"] == 10
 
 
 def test_run_cell_asyncio_run():
     ip.run_cell("import asyncio")
     result = ip.run_cell("await asyncio.sleep(0.01); 1")
     assert ip.user_ns["_"] == 1
     result = ip.run_cell("asyncio.run(asyncio.sleep(0.01)); 2")
     assert ip.user_ns["_"] == 2
     result = ip.run_cell("await asyncio.sleep(0.01); 3")
     assert ip.user_ns["_"] == 3
 
 
 def test_should_run_async():
     assert not ip.should_run_async("a = 5")
     assert ip.should_run_async("await x")
     assert ip.should_run_async("import asyncio; await asyncio.sleep(1)")
 
 
 def test_set_custom_completer():
     num_completers = len(ip.Completer.matchers)
 
     def foo(*args, **kwargs):
         return "I'm a completer!"
 
     ip.set_custom_completer(foo, 0)
 
     # check that we've really added a new completer
     assert len(ip.Completer.matchers) == num_completers + 1
 
     # check that the first completer is the function we defined
     assert ip.Completer.matchers[0]() == "I'm a completer!"
 
     # clean up
     ip.Completer.custom_matchers.pop()

IPython/core/tests/test_iplib.py

@@ -1,249 +1,250 b''
 """Tests for the key interactiveshell module, where the main ipython class is defined.
 """
 #-----------------------------------------------------------------------------
 # Module imports
 #-----------------------------------------------------------------------------
 
 # third party
 import pytest
 
 # our own packages
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 
 def test_reset():
     """reset must clear most namespaces."""
 
     # Check that reset runs without error
     ip.reset()
 
     # Once we've reset it (to clear of any junk that might have been there from
     # other tests, we can count how many variables are in the user's namespace
     nvars_user_ns = len(ip.user_ns)
     nvars_hidden = len(ip.user_ns_hidden)
 
     # Now add a few variables to user_ns, and check that reset clears them
     ip.user_ns['x'] = 1
     ip.user_ns['y'] = 1
     ip.reset()
     
     # Finally, check that all namespaces have only as many variables as we
     # expect to find in them:
     assert len(ip.user_ns) == nvars_user_ns
     assert len(ip.user_ns_hidden) == nvars_hidden
 
 
 # Tests for reporting of exceptions in various modes, handling of SystemExit,
 # and %tb functionality.  This is really a mix of testing ultraTB and interactiveshell.
 
 def doctest_tb_plain():
     """
     In [18]: xmode plain
     Exception reporting mode: Plain
 
     In [19]: run simpleerr.py
     Traceback (most recent call last):
       File ...:... in <module>
         bar(mode)
       File ...:... in bar
         div0()
       File ...:... in div0
         x/y
     ZeroDivisionError: ...
     """
 
 
 def doctest_tb_context():
     """
     In [3]: xmode context
     Exception reporting mode: Context
 
     In [4]: run simpleerr.py
     ---------------------------------------------------------------------------
     ZeroDivisionError                         Traceback (most recent call last)
     <BLANKLINE>
     ... in <module>
          30     except IndexError:
          31         mode = 'div'
     ---> 33     bar(mode)
     <BLANKLINE>
     ... in bar(mode)
          15     "bar"
          16     if mode=='div':
     ---> 17         div0()
          18     elif mode=='exit':
          19         try:
     <BLANKLINE>
     ... in div0()
           6     x = 1
           7     y = 0
     ----> 8     x/y
     <BLANKLINE>
     ZeroDivisionError: ..."""
 
 
 def doctest_tb_verbose():
     """
     In [5]: xmode verbose
     Exception reporting mode: Verbose
 
     In [6]: run simpleerr.py
     ---------------------------------------------------------------------------
     ZeroDivisionError                         Traceback (most recent call last)
     <BLANKLINE>
     ... in <module>
          30     except IndexError:
          31         mode = 'div'
     ---> 33     bar(mode)
             mode = 'div'
     <BLANKLINE>
     ... in bar(mode='div')
          15     "bar"
          16     if mode=='div':
     ---> 17         div0()
          18     elif mode=='exit':
          19         try:
     <BLANKLINE>
     ... in div0()
           6     x = 1
           7     y = 0
     ----> 8     x/y
             x = 1
             y = 0
     <BLANKLINE>
     ZeroDivisionError: ...
     """
 
 
 def doctest_tb_sysexit():
     """
     In [17]: %xmode plain
     Exception reporting mode: Plain
 
     In [18]: %run simpleerr.py exit
     An exception has occurred, use %tb to see the full traceback.
     SystemExit: (1, 'Mode = exit')
 
     In [19]: %run simpleerr.py exit 2
     An exception has occurred, use %tb to see the full traceback.
     SystemExit: (2, 'Mode = exit')
 
     In [20]: %tb
     Traceback (most recent call last):
       File ...:... in execfile
         exec(compiler(f.read(), fname, "exec"), glob, loc)
       File ...:... in <module>
         bar(mode)
       File ...:... in bar
         sysexit(stat, mode)
       File ...:... in sysexit
         raise SystemExit(stat, f"Mode = {mode}")
     SystemExit: (2, 'Mode = exit')
 
     In [21]: %xmode context
     Exception reporting mode: Context
 
     In [22]: %tb
     ---------------------------------------------------------------------------
     SystemExit                                Traceback (most recent call last)
     File ..., in execfile(fname, glob, loc, compiler)
          ... with open(fname, "rb") as f:
          ...     compiler = compiler or compile
     ---> ...     exec(compiler(f.read(), fname, "exec"), glob, loc)
     ...<module>
          30     except IndexError:
          31         mode = 'div'
     ---> 33     bar(mode)
     <BLANKLINE>
     ...bar(mode)
          21         except:
          22             stat = 1
     ---> 23         sysexit(stat, mode)
          24     else:
          25         raise ValueError('Unknown mode')
     <BLANKLINE>
     ...sysexit(stat, mode)
          10 def sysexit(stat, mode):
     ---> 11     raise SystemExit(stat, f"Mode = {mode}")
     <BLANKLINE>
     SystemExit: (2, 'Mode = exit')
     """
 
 
 def doctest_tb_sysexit_verbose():
     """
     In [18]: %run simpleerr.py exit
     An exception has occurred, use %tb to see the full traceback.
     SystemExit: (1, 'Mode = exit')
 
     In [19]: %run simpleerr.py exit 2
     An exception has occurred, use %tb to see the full traceback.
     SystemExit: (2, 'Mode = exit')
 
     In [23]: %xmode verbose
     Exception reporting mode: Verbose
 
     In [24]: %tb
     ---------------------------------------------------------------------------
     SystemExit                                Traceback (most recent call last)
     <BLANKLINE>
     ... in <module>
          30     except IndexError:
          31         mode = 'div'
     ---> 33     bar(mode)
             mode = 'exit'
     <BLANKLINE>
     ... in bar(mode='exit')
          ...     except:
          ...         stat = 1
     ---> ...     sysexit(stat, mode)
             mode = 'exit'
             stat = 2
          ...     else:
          ...         raise ValueError('Unknown mode')
     <BLANKLINE>
     ... in sysexit(stat=2, mode='exit')
          10 def sysexit(stat, mode):
     ---> 11     raise SystemExit(stat, f"Mode = {mode}")
             stat = 2
     <BLANKLINE>
     SystemExit: (2, 'Mode = exit')
     """
 
 
 def test_run_cell():
     import textwrap
 
     ip.run_cell("a = 10\na+=1")
     ip.run_cell("assert a == 11\nassert 1")
 
     assert ip.user_ns["a"] == 11
     complex = textwrap.dedent(
         """
     if 1:
         print "hello"
         if 1:
             print "world"
         
     if 2:
         print "foo"
 
     if 3:
         print "bar"
 
     if 4:
         print "bar"
     
-    """)
+    """
+    )
     # Simply verifies that this kind of input is run
     ip.run_cell(complex)
     
 
 def test_db():
     """Test the internal database used for variable persistence."""
     ip.db["__unittest_"] = 12
     assert ip.db["__unittest_"] == 12
     del ip.db["__unittest_"]
     assert "__unittest_" not in ip.db

IPython/core/tests/test_magic.py

@@ -1,1450 +1,1452 b''
 # -*- coding: utf-8 -*-
 """Tests for various magic functions."""
 
 import asyncio
 import gc
 import io
 import os
 import re
 import shlex
 import sys
 import warnings
 from importlib import invalidate_caches
 from io import StringIO
 from pathlib import Path
 from textwrap import dedent
 from unittest import TestCase, mock
 
 import pytest
 
 from IPython import get_ipython
 from IPython.core import magic
 from IPython.core.error import UsageError
 from IPython.core.magic import (
     Magics,
     cell_magic,
     line_magic,
     magics_class,
     register_cell_magic,
     register_line_magic,
 )
 from IPython.core.magics import code, execution, logging, osm, script
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 from IPython.utils.io import capture_output
 from IPython.utils.process import find_cmd
 from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
 from IPython.utils.syspathcontext import prepended_to_syspath
 
 from .test_debugger import PdbTestInput
 
 from tempfile import NamedTemporaryFile
 
 @magic.magics_class
 class DummyMagics(magic.Magics): pass
 
 def test_extract_code_ranges():
     instr = "1 3 5-6 7-9 10:15 17: :10 10- -13 :"
     expected = [
         (0, 1),
         (2, 3),
         (4, 6),
         (6, 9),
         (9, 14),
         (16, None),
         (None, 9),
         (9, None),
         (None, 13),
         (None, None),
     ]
     actual = list(code.extract_code_ranges(instr))
     assert actual == expected
 
 def test_extract_symbols():
     source = """import foo\na = 10\ndef b():\n    return 42\n\n\nclass A: pass\n\n\n"""
     symbols_args = ["a", "b", "A", "A,b", "A,a", "z"]
     expected = [([], ['a']),
                 (["def b():\n    return 42\n"], []),
                 (["class A: pass\n"], []),
                 (["class A: pass\n", "def b():\n    return 42\n"], []),
                 (["class A: pass\n"], ['a']),
                 ([], ['z'])]
     for symbols, exp in zip(symbols_args, expected):
         assert code.extract_symbols(source, symbols) == exp
 
 
 def test_extract_symbols_raises_exception_with_non_python_code():
     source = ("=begin A Ruby program :)=end\n"
               "def hello\n"
               "puts 'Hello world'\n"
               "end")
     with pytest.raises(SyntaxError):
         code.extract_symbols(source, "hello")
 
 
 def test_magic_not_found():
     # magic not found raises UsageError
     with pytest.raises(UsageError):
         _ip.magic('doesntexist')
 
     # ensure result isn't success when a magic isn't found
     result = _ip.run_cell('%doesntexist')
     assert isinstance(result.error_in_exec, UsageError)
 
 
 def test_cell_magic_not_found():
     # magic not found raises UsageError
     with pytest.raises(UsageError):
         _ip.run_cell_magic('doesntexist', 'line', 'cell')
 
     # ensure result isn't success when a magic isn't found
     result = _ip.run_cell('%%doesntexist')
     assert isinstance(result.error_in_exec, UsageError)
 
 
 def test_magic_error_status():
     def fail(shell):
         1/0
     _ip.register_magic_function(fail)
     result = _ip.run_cell('%fail')
     assert isinstance(result.error_in_exec, ZeroDivisionError)
 
 
 def test_config():
     """ test that config magic does not raise
     can happen if Configurable init is moved too early into
     Magics.__init__ as then a Config object will be registered as a
     magic.
     """
     ## should not raise.
     _ip.magic('config')
 
 def test_config_available_configs():
     """ test that config magic prints available configs in unique and
     sorted order. """
     with capture_output() as captured:
         _ip.magic('config')
 
     stdout = captured.stdout
     config_classes = stdout.strip().split('\n')[1:]
     assert config_classes == sorted(set(config_classes))
 
 def test_config_print_class():
     """ test that config with a classname prints the class's options. """
     with capture_output() as captured:
         _ip.magic('config TerminalInteractiveShell')
 
     stdout = captured.stdout
     assert re.match(
         "TerminalInteractiveShell.* options", stdout.splitlines()[0]
     ), f"{stdout}\n\n1st line of stdout not like 'TerminalInteractiveShell.* options'"
 
 
 def test_rehashx():
     # clear up everything
     _ip.alias_manager.clear_aliases()
     del _ip.db['syscmdlist']
 
     _ip.magic('rehashx')
     # Practically ALL ipython development systems will have more than 10 aliases
 
     assert len(_ip.alias_manager.aliases) > 10
     for name, cmd in _ip.alias_manager.aliases:
         # we must strip dots from alias names
         assert "." not in name
 
     # rehashx must fill up syscmdlist
     scoms = _ip.db['syscmdlist']
     assert len(scoms) > 10
 
 
 def test_magic_parse_options():
     """Test that we don't mangle paths when parsing magic options."""
     ip = get_ipython()
     path = 'c:\\x'
     m = DummyMagics(ip)
     opts = m.parse_options('-f %s' % path,'f:')[0]
     # argv splitting is os-dependent
     if os.name == 'posix':
         expected = 'c:x'
     else:
         expected = path
     assert opts["f"] == expected
 
 
 def test_magic_parse_long_options():
     """Magic.parse_options can handle --foo=bar long options"""
     ip = get_ipython()
     m = DummyMagics(ip)
     opts, _ = m.parse_options("--foo --bar=bubble", "a", "foo", "bar=")
     assert "foo" in opts
     assert "bar" in opts
     assert opts["bar"] == "bubble"
 
 
 def doctest_hist_f():
     """Test %hist -f with temporary filename.
 
     In [9]: import tempfile
 
     In [10]: tfile = tempfile.mktemp('.py','tmp-ipython-')
 
     In [11]: %hist -nl -f $tfile 3
 
     In [13]: import os; os.unlink(tfile)
     """
 
 
 def doctest_hist_op():
     """Test %hist -op
 
     In [1]: class b(float):
        ...:     pass
        ...:
 
     In [2]: class s(object):
        ...:     def __str__(self):
        ...:         return 's'
        ...:
 
     In [3]:
 
     In [4]: class r(b):
        ...:     def __repr__(self):
        ...:         return 'r'
        ...:
 
     In [5]: class sr(s,r): pass
        ...:
 
     In [6]:
 
     In [7]: bb=b()
 
     In [8]: ss=s()
 
     In [9]: rr=r()
 
     In [10]: ssrr=sr()
 
     In [11]: 4.5
     Out[11]: 4.5
 
     In [12]: str(ss)
     Out[12]: 's'
 
     In [13]:
 
     In [14]: %hist -op
     >>> class b:
     ...     pass
     ...
     >>> class s(b):
     ...     def __str__(self):
     ...         return 's'
     ...
     >>>
     >>> class r(b):
     ...     def __repr__(self):
     ...         return 'r'
     ...
     >>> class sr(s,r): pass
     >>>
     >>> bb=b()
     >>> ss=s()
     >>> rr=r()
     >>> ssrr=sr()
     >>> 4.5
     4.5
     >>> str(ss)
     's'
     >>>
     """
 
 def test_hist_pof():
     ip = get_ipython()
     ip.run_cell("1+2", store_history=True)
     #raise Exception(ip.history_manager.session_number)
     #raise Exception(list(ip.history_manager._get_range_session()))
     with TemporaryDirectory() as td:
         tf = os.path.join(td, 'hist.py')
         ip.run_line_magic('history', '-pof %s' % tf)
         assert os.path.isfile(tf)
 
 
 def test_macro():
     ip = get_ipython()
     ip.history_manager.reset()   # Clear any existing history.
     cmds = ["a=1", "def b():\n  return a**2", "print(a,b())"]
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
     ip.magic("macro test 1-3")
     assert ip.user_ns["test"].value == "\n".join(cmds) + "\n"
 
     # List macros
     assert "test" in ip.magic("macro")
 
 
 def test_macro_run():
     """Test that we can run a multi-line macro successfully."""
     ip = get_ipython()
     ip.history_manager.reset()
     cmds = ["a=10", "a+=1", "print(a)", "%macro test 2-3"]
     for cmd in cmds:
         ip.run_cell(cmd, store_history=True)
     assert ip.user_ns["test"].value == "a+=1\nprint(a)\n"
     with tt.AssertPrints("12"):
         ip.run_cell("test")
     with tt.AssertPrints("13"):
         ip.run_cell("test")
 
 
 def test_magic_magic():
     """Test %magic"""
     ip = get_ipython()
     with capture_output() as captured:
         ip.magic("magic")
 
     stdout = captured.stdout
     assert "%magic" in stdout
     assert "IPython" in stdout
     assert "Available" in stdout
 
 
 @dec.skipif_not_numpy
 def test_numpy_reset_array_undec():
     "Test '%reset array' functionality"
     _ip.ex("import numpy as np")
     _ip.ex("a = np.empty(2)")
     assert "a" in _ip.user_ns
     _ip.magic("reset -f array")
     assert "a" not in _ip.user_ns
 
 
 def test_reset_out():
     "Test '%reset out' magic"
     _ip.run_cell("parrot = 'dead'", store_history=True)
     # test '%reset -f out', make an Out prompt
     _ip.run_cell("parrot", store_history=True)
     assert "dead" in [_ip.user_ns[x] for x in ("_", "__", "___")]
     _ip.magic("reset -f out")
     assert "dead" not in [_ip.user_ns[x] for x in ("_", "__", "___")]
     assert len(_ip.user_ns["Out"]) == 0
 
 
 def test_reset_in():
     "Test '%reset in' magic"
     # test '%reset -f in'
     _ip.run_cell("parrot", store_history=True)
     assert "parrot" in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")]
     _ip.magic("%reset -f in")
     assert "parrot" not in [_ip.user_ns[x] for x in ("_i", "_ii", "_iii")]
     assert len(set(_ip.user_ns["In"])) == 1
 
 
 def test_reset_dhist():
     "Test '%reset dhist' magic"
     _ip.run_cell("tmp = [d for d in _dh]")  # copy before clearing
     _ip.magic("cd " + os.path.dirname(pytest.__file__))
     _ip.magic("cd -")
     assert len(_ip.user_ns["_dh"]) > 0
     _ip.magic("reset -f dhist")
     assert len(_ip.user_ns["_dh"]) == 0
     _ip.run_cell("_dh = [d for d in tmp]")  # restore
 
 
 def test_reset_in_length():
     "Test that '%reset in' preserves In[] length"
     _ip.run_cell("print 'foo'")
     _ip.run_cell("reset -f in")
     assert len(_ip.user_ns["In"]) == _ip.displayhook.prompt_count + 1
 
 
 class TestResetErrors(TestCase):
 
     def test_reset_redefine(self):
 
         @magics_class
         class KernelMagics(Magics):
               @line_magic
               def less(self, shell): pass
 
         _ip.register_magics(KernelMagics)
 
         with self.assertLogs() as cm:
             # hack, we want to just capture logs, but assertLogs fails if not
             # logs get produce.
             # so log one things we ignore.
             import logging as log_mod
             log = log_mod.getLogger()
             log.info('Nothing')
             # end hack.
             _ip.run_cell("reset -f")
 
         assert len(cm.output) == 1
         for out in cm.output:
             assert "Invalid alias" not in out
 
 def test_tb_syntaxerror():
     """test %tb after a SyntaxError"""
     ip = get_ipython()
     ip.run_cell("for")
 
     # trap and validate stdout
     save_stdout = sys.stdout
     try:
         sys.stdout = StringIO()
         ip.run_cell("%tb")
         out = sys.stdout.getvalue()
     finally:
         sys.stdout = save_stdout
     # trim output, and only check the last line
     last_line = out.rstrip().splitlines()[-1].strip()
     assert last_line == "SyntaxError: invalid syntax"
 
 
 def test_time():
     ip = get_ipython()
 
     with tt.AssertPrints("Wall time: "):
         ip.run_cell("%time None")
 
     ip.run_cell("def f(kmjy):\n"
                 "    %time print (2*kmjy)")
 
     with tt.AssertPrints("Wall time: "):
         with tt.AssertPrints("hihi", suppress=False):
             ip.run_cell("f('hi')")
 
 def test_time_last_not_expression():
     ip.run_cell("%%time\n"
                 "var_1 = 1\n"
                 "var_2 = 2\n")
     assert ip.user_ns['var_1'] == 1
     del ip.user_ns['var_1']
     assert ip.user_ns['var_2'] == 2
     del ip.user_ns['var_2']
 
 
 @dec.skip_win32
 def test_time2():
     ip = get_ipython()
 
     with tt.AssertPrints("CPU times: user "):
         ip.run_cell("%time None")
 
 def test_time3():
     """Erroneous magic function calls, issue gh-3334"""
     ip = get_ipython()
     ip.user_ns.pop('run', None)
 
     with tt.AssertNotPrints("not found", channel='stderr'):
         ip.run_cell("%%time\n"
                     "run = 0\n"
                     "run += 1")
 
 def test_multiline_time():
     """Make sure last statement from time return a value."""
     ip = get_ipython()
     ip.user_ns.pop('run', None)
 
-    ip.run_cell(dedent("""\
+    ip.run_cell(
+        dedent(
+            """\
         %%time
         a = "ho"
         b = "hey"
         a+b
         """
         )
     )
     assert ip.user_ns_hidden["_"] == "hohey"
 
 
 def test_time_local_ns():
     """
     Test that local_ns is actually global_ns when running a cell magic
     """
     ip = get_ipython()
     ip.run_cell("%%time\n" "myvar = 1")
     assert ip.user_ns["myvar"] == 1
     del ip.user_ns["myvar"]
 
 
 def test_doctest_mode():
     "Toggle doctest_mode twice, it should be a no-op and run without error"
     _ip.magic('doctest_mode')
     _ip.magic('doctest_mode')
 
 
 def test_parse_options():
     """Tests for basic options parsing in magics."""
     # These are only the most minimal of tests, more should be added later.  At
     # the very least we check that basic text/unicode calls work OK.
     m = DummyMagics(_ip)
     assert m.parse_options("foo", "")[1] == "foo"
     assert m.parse_options("foo", "")[1] == "foo"
 
 
 def test_parse_options_preserve_non_option_string():
     """Test to assert preservation of non-option part of magic-block, while parsing magic options."""
     m = DummyMagics(_ip)
     opts, stmt = m.parse_options(
         " -n1  -r 13 _ = 314 + foo", "n:r:", preserve_non_opts=True
     )
     assert opts == {"n": "1", "r": "13"}
     assert stmt == "_ = 314 + foo"
 
 
 def test_run_magic_preserve_code_block():
     """Test to assert preservation of non-option part of magic-block, while running magic."""
     _ip.user_ns["spaces"] = []
     _ip.magic("timeit -n1 -r1 spaces.append([s.count(' ') for s in ['document']])")
     assert _ip.user_ns["spaces"] == [[0]]
 
 
 def test_dirops():
     """Test various directory handling operations."""
     # curpath = lambda :os.path.splitdrive(os.getcwd())[1].replace('\\','/')
     curpath = os.getcwd
     startdir = os.getcwd()
     ipdir = os.path.realpath(_ip.ipython_dir)
     try:
         _ip.magic('cd "%s"' % ipdir)
         assert curpath() == ipdir
         _ip.magic('cd -')
         assert curpath() == startdir
         _ip.magic('pushd "%s"' % ipdir)
         assert curpath() == ipdir
         _ip.magic('popd')
         assert curpath() == startdir
     finally:
         os.chdir(startdir)
 
 
 def test_cd_force_quiet():
     """Test OSMagics.cd_force_quiet option"""
     _ip.config.OSMagics.cd_force_quiet = True
     osmagics = osm.OSMagics(shell=_ip)
 
     startdir = os.getcwd()
     ipdir = os.path.realpath(_ip.ipython_dir)
 
     try:
         with tt.AssertNotPrints(ipdir):
             osmagics.cd('"%s"' % ipdir)
         with tt.AssertNotPrints(startdir):
             osmagics.cd('-')
     finally:
         os.chdir(startdir)
 
 
 def test_xmode():
     # Calling xmode three times should be a no-op
     xmode = _ip.InteractiveTB.mode
     for i in range(4):
         _ip.magic("xmode")
     assert _ip.InteractiveTB.mode == xmode
 
 def test_reset_hard():
     monitor = []
     class A(object):
         def __del__(self):
             monitor.append(1)
         def __repr__(self):
             return "<A instance>"
 
     _ip.user_ns["a"] = A()
     _ip.run_cell("a")
 
     assert monitor == []
     _ip.magic("reset -f")
     assert monitor == [1]
 
 class TestXdel(tt.TempFileMixin):
     def test_xdel(self):
         """Test that references from %run are cleared by xdel."""
         src = ("class A(object):\n"
                "    monitor = []\n"
                "    def __del__(self):\n"
                "        self.monitor.append(1)\n"
                "a = A()\n")
         self.mktmp(src)
         # %run creates some hidden references...
         _ip.magic("run %s" % self.fname)
         # ... as does the displayhook.
         _ip.run_cell("a")
 
         monitor = _ip.user_ns["A"].monitor
         assert monitor == []
 
         _ip.magic("xdel a")
 
         # Check that a's __del__ method has been called.
         gc.collect(0)
         assert monitor == [1]
 
 def doctest_who():
     """doctest for %who
 
     In [1]: %reset -sf
 
     In [2]: alpha = 123
 
     In [3]: beta = 'beta'
 
     In [4]: %who int
     alpha
 
     In [5]: %who str
     beta
 
     In [6]: %whos
     Variable   Type    Data/Info
     ----------------------------
     alpha      int     123
     beta       str     beta
 
     In [7]: %who_ls
     Out[7]: ['alpha', 'beta']
     """
 
 def test_whos():
     """Check that whos is protected against objects where repr() fails."""
     class A(object):
         def __repr__(self):
             raise Exception()
     _ip.user_ns['a'] = A()
     _ip.magic("whos")
 
 def doctest_precision():
     """doctest for %precision
 
     In [1]: f = get_ipython().display_formatter.formatters['text/plain']
 
     In [2]: %precision 5
     Out[2]: '%.5f'
 
     In [3]: f.float_format
     Out[3]: '%.5f'
 
     In [4]: %precision %e
     Out[4]: '%e'
 
     In [5]: f(3.1415927)
     Out[5]: '3.141593e+00'
     """
 
 def test_debug_magic():
     """Test debugging a small code with %debug
 
     In [1]: with PdbTestInput(['c']):
        ...:     %debug print("a b") #doctest: +ELLIPSIS
        ...:
     ...
     ipdb> c
     a b
     In [2]:
     """
 
 def test_psearch():
     with tt.AssertPrints("dict.fromkeys"):
         _ip.run_cell("dict.fr*?")
     with tt.AssertPrints("π.is_integer"):
         _ip.run_cell("π = 3.14;\nπ.is_integ*?")
 
 def test_timeit_shlex():
     """test shlex issues with timeit (#1109)"""
     _ip.ex("def f(*a,**kw): pass")
     _ip.magic('timeit -n1 "this is a bug".count(" ")')
     _ip.magic('timeit -r1 -n1 f(" ", 1)')
     _ip.magic('timeit -r1 -n1 f(" ", 1, " ", 2, " ")')
     _ip.magic('timeit -r1 -n1 ("a " + "b")')
     _ip.magic('timeit -r1 -n1 f("a " + "b")')
     _ip.magic('timeit -r1 -n1 f("a " + "b ")')
 
 
 def test_timeit_special_syntax():
     "Test %%timeit with IPython special syntax"
     @register_line_magic
     def lmagic(line):
         ip = get_ipython()
         ip.user_ns['lmagic_out'] = line
 
     # line mode test
     _ip.run_line_magic("timeit", "-n1 -r1 %lmagic my line")
     assert _ip.user_ns["lmagic_out"] == "my line"
     # cell mode test
     _ip.run_cell_magic("timeit", "-n1 -r1", "%lmagic my line2")
     assert _ip.user_ns["lmagic_out"] == "my line2"
 
 
 def test_timeit_return():
     """
     test whether timeit -o return object
     """
 
     res = _ip.run_line_magic('timeit','-n10 -r10 -o 1')
     assert(res is not None)
 
 def test_timeit_quiet():
     """
     test quiet option of timeit magic
     """
     with tt.AssertNotPrints("loops"):
         _ip.run_cell("%timeit -n1 -r1 -q 1")
 
 def test_timeit_return_quiet():
     with tt.AssertNotPrints("loops"):
         res = _ip.run_line_magic('timeit', '-n1 -r1 -q -o 1')
     assert (res is not None)
 
 def test_timeit_invalid_return():
     with pytest.raises(SyntaxError):
         _ip.run_line_magic('timeit', 'return')
 
 @dec.skipif(execution.profile is None)
 def test_prun_special_syntax():
     "Test %%prun with IPython special syntax"
     @register_line_magic
     def lmagic(line):
         ip = get_ipython()
         ip.user_ns['lmagic_out'] = line
 
     # line mode test
     _ip.run_line_magic("prun", "-q %lmagic my line")
     assert _ip.user_ns["lmagic_out"] == "my line"
     # cell mode test
     _ip.run_cell_magic("prun", "-q", "%lmagic my line2")
     assert _ip.user_ns["lmagic_out"] == "my line2"
 
 
 @dec.skipif(execution.profile is None)
 def test_prun_quotes():
     "Test that prun does not clobber string escapes (GH #1302)"
     _ip.magic(r"prun -q x = '\t'")
     assert _ip.user_ns["x"] == "\t"
 
 
 def test_extension():
     # Debugging information for failures of this test
     print('sys.path:')
     for p in sys.path:
         print(' ', p)
     print('CWD', os.getcwd())
 
     pytest.raises(ImportError, _ip.magic, "load_ext daft_extension")
     daft_path = os.path.join(os.path.dirname(__file__), "daft_extension")
     sys.path.insert(0, daft_path)
     try:
         _ip.user_ns.pop('arq', None)
         invalidate_caches()   # Clear import caches
         _ip.magic("load_ext daft_extension")
         assert _ip.user_ns["arq"] == 185
         _ip.magic("unload_ext daft_extension")
         assert 'arq' not in _ip.user_ns
     finally:
         sys.path.remove(daft_path)
 
 
 def test_notebook_export_json():
     pytest.importorskip("nbformat")
     _ip = get_ipython()
     _ip.history_manager.reset()   # Clear any existing history.
     cmds = ["a=1", "def b():\n  return a**2", "print('noël, été', b())"]
     for i, cmd in enumerate(cmds, start=1):
         _ip.history_manager.store_inputs(i, cmd)
     with TemporaryDirectory() as td:
         outfile = os.path.join(td, "nb.ipynb")
         _ip.magic("notebook %s" % outfile)
 
 
 class TestEnv(TestCase):
 
     def test_env(self):
         env = _ip.magic("env")
         self.assertTrue(isinstance(env, dict))
 
     def test_env_secret(self):
         env = _ip.magic("env")
         hidden = "<hidden>"
         with mock.patch.dict(
             os.environ,
             {
                 "API_KEY": "abc123",
                 "SECRET_THING": "ssshhh",
                 "JUPYTER_TOKEN": "",
                 "VAR": "abc"
             }
         ):
             env = _ip.magic("env")
         assert env["API_KEY"] == hidden
         assert env["SECRET_THING"] == hidden
         assert env["JUPYTER_TOKEN"] == hidden
         assert env["VAR"] == "abc"
 
     def test_env_get_set_simple(self):
         env = _ip.magic("env var val1")
         self.assertEqual(env, None)
         self.assertEqual(os.environ['var'], 'val1')
         self.assertEqual(_ip.magic("env var"), 'val1')
         env = _ip.magic("env var=val2")
         self.assertEqual(env, None)
         self.assertEqual(os.environ['var'], 'val2')
 
     def test_env_get_set_complex(self):
         env = _ip.magic("env var 'val1 '' 'val2")
         self.assertEqual(env, None)
         self.assertEqual(os.environ['var'], "'val1 '' 'val2")
         self.assertEqual(_ip.magic("env var"), "'val1 '' 'val2")
         env = _ip.magic('env var=val2 val3="val4')
         self.assertEqual(env, None)
         self.assertEqual(os.environ['var'], 'val2 val3="val4')
 
     def test_env_set_bad_input(self):
         self.assertRaises(UsageError, lambda: _ip.magic("set_env var"))
 
     def test_env_set_whitespace(self):
         self.assertRaises(UsageError, lambda: _ip.magic("env var A=B"))
 
 
 class CellMagicTestCase(TestCase):
 
     def check_ident(self, magic):
         # Manually called, we get the result
         out = _ip.run_cell_magic(magic, "a", "b")
         assert out == ("a", "b")
         # Via run_cell, it goes into the user's namespace via displayhook
         _ip.run_cell("%%" + magic + " c\nd\n")
         assert _ip.user_ns["_"] == ("c", "d\n")
 
     def test_cell_magic_func_deco(self):
         "Cell magic using simple decorator"
         @register_cell_magic
         def cellm(line, cell):
             return line, cell
 
         self.check_ident('cellm')
 
     def test_cell_magic_reg(self):
         "Cell magic manually registered"
         def cellm(line, cell):
             return line, cell
 
         _ip.register_magic_function(cellm, 'cell', 'cellm2')
         self.check_ident('cellm2')
 
     def test_cell_magic_class(self):
         "Cell magics declared via a class"
         @magics_class
         class MyMagics(Magics):
 
             @cell_magic
             def cellm3(self, line, cell):
                 return line, cell
 
         _ip.register_magics(MyMagics)
         self.check_ident('cellm3')
 
     def test_cell_magic_class2(self):
         "Cell magics declared via a class, #2"
         @magics_class
         class MyMagics2(Magics):
 
             @cell_magic('cellm4')
             def cellm33(self, line, cell):
                 return line, cell
 
         _ip.register_magics(MyMagics2)
         self.check_ident('cellm4')
         # Check that nothing is registered as 'cellm33'
         c33 = _ip.find_cell_magic('cellm33')
         assert c33 == None
 
 def test_file():
     """Basic %%writefile"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, "file1")
         ip.run_cell_magic(
             "writefile",
             fname,
             "\n".join(
                 [
                     "line1",
                     "line2",
                 ]
             ),
         )
         s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
 
 @dec.skip_win32
 def test_file_single_quote():
     """Basic %%writefile with embedded single quotes"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, "'file1'")
         ip.run_cell_magic(
             "writefile",
             fname,
             "\n".join(
                 [
                     "line1",
                     "line2",
                 ]
             ),
         )
         s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
 
 @dec.skip_win32
 def test_file_double_quote():
     """Basic %%writefile with embedded double quotes"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, '"file1"')
         ip.run_cell_magic(
             "writefile",
             fname,
             "\n".join(
                 [
                     "line1",
                     "line2",
                 ]
             ),
         )
         s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
 
 def test_file_var_expand():
     """%%writefile $filename"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, "file1")
         ip.user_ns["filename"] = fname
         ip.run_cell_magic(
             "writefile",
             "$filename",
             "\n".join(
                 [
                     "line1",
                     "line2",
                 ]
             ),
         )
         s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
 
 def test_file_unicode():
     """%%writefile with unicode cell"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, 'file1')
         ip.run_cell_magic("writefile", fname, u'\n'.join([
             u'liné1',
             u'liné2',
         ]))
         with io.open(fname, encoding='utf-8') as f:
             s = f.read()
         assert "liné1\n" in s
         assert "liné2" in s
 
 
 def test_file_amend():
     """%%writefile -a amends files"""
     ip = get_ipython()
     with TemporaryDirectory() as td:
         fname = os.path.join(td, "file2")
         ip.run_cell_magic(
             "writefile",
             fname,
             "\n".join(
                 [
                     "line1",
                     "line2",
                 ]
             ),
         )
         ip.run_cell_magic(
             "writefile",
             "-a %s" % fname,
             "\n".join(
                 [
                     "line3",
                     "line4",
                 ]
             ),
         )
         s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line3\n" in s
 
 
 def test_file_spaces():
     """%%file with spaces in filename"""
     ip = get_ipython()
     with TemporaryWorkingDirectory() as td:
         fname = "file name"
         ip.run_cell_magic(
             "file",
             '"%s"' % fname,
             "\n".join(
                 [
                     "line1",
                     "line2",
                 ]
             ),
         )
         s = Path(fname).read_text(encoding="utf-8")
         assert "line1\n" in s
         assert "line2" in s
 
 
 def test_script_config():
     ip = get_ipython()
     ip.config.ScriptMagics.script_magics = ['whoda']
     sm = script.ScriptMagics(shell=ip)
     assert "whoda" in sm.magics["cell"]
 
 
 def test_script_out():
     ip = get_ipython()
     ip.run_cell_magic("script", f"--out output {sys.executable}", "print('hi')")
     assert ip.user_ns["output"].strip() == "hi"
 
 
 def test_script_err():
     ip = get_ipython()
     ip.run_cell_magic(
         "script",
         f"--err error {sys.executable}",
         "import sys; print('hello', file=sys.stderr)",
     )
     assert ip.user_ns["error"].strip() == "hello"
 
 
 def test_script_out_err():
 
     ip = get_ipython()
     ip.run_cell_magic(
         "script",
         f"--out output --err error {sys.executable}",
         "\n".join(
             [
                 "import sys",
                 "print('hi')",
                 "print('hello', file=sys.stderr)",
             ]
         ),
     )
     assert ip.user_ns["output"].strip() == "hi"
     assert ip.user_ns["error"].strip() == "hello"
 
 
 async def test_script_bg_out():
     ip = get_ipython()
     ip.run_cell_magic("script", f"--bg --out output {sys.executable}", "print('hi')")
     assert (await ip.user_ns["output"].read()).strip() == b"hi"
     assert ip.user_ns["output"].at_eof()
 
 
 async def test_script_bg_err():
     ip = get_ipython()
     ip.run_cell_magic(
         "script",
         f"--bg --err error {sys.executable}",
         "import sys; print('hello', file=sys.stderr)",
     )
     assert (await ip.user_ns["error"].read()).strip() == b"hello"
     assert ip.user_ns["error"].at_eof()
 
 
 async def test_script_bg_out_err():
     ip = get_ipython()
     ip.run_cell_magic(
         "script",
         f"--bg --out output --err error {sys.executable}",
         "\n".join(
             [
                 "import sys",
                 "print('hi')",
                 "print('hello', file=sys.stderr)",
             ]
         ),
     )
     assert (await ip.user_ns["output"].read()).strip() == b"hi"
     assert (await ip.user_ns["error"].read()).strip() == b"hello"
     assert ip.user_ns["output"].at_eof()
     assert ip.user_ns["error"].at_eof()
 
 
 async def test_script_bg_proc():
     ip = get_ipython()
     ip.run_cell_magic(
         "script",
         f"--bg --out output --proc p {sys.executable}",
         "\n".join(
             [
                 "import sys",
                 "print('hi')",
                 "print('hello', file=sys.stderr)",
             ]
         ),
     )
     p = ip.user_ns["p"]
     await p.wait()
     assert p.returncode == 0
     assert (await p.stdout.read()).strip() == b"hi"
     # not captured, so empty
     assert (await p.stderr.read()) == b""
     assert p.stdout.at_eof()
     assert p.stderr.at_eof()
 
 
 def test_script_defaults():
     ip = get_ipython()
     for cmd in ['sh', 'bash', 'perl', 'ruby']:
         try:
             find_cmd(cmd)
         except Exception:
             pass
         else:
             assert cmd in ip.magics_manager.magics["cell"]
 
 
 @magics_class
 class FooFoo(Magics):
     """class with both %foo and %%foo magics"""
     @line_magic('foo')
     def line_foo(self, line):
         "I am line foo"
         pass
 
     @cell_magic("foo")
     def cell_foo(self, line, cell):
         "I am cell foo, not line foo"
         pass
 
 def test_line_cell_info():
     """%%foo and %foo magics are distinguishable to inspect"""
     ip = get_ipython()
     ip.magics_manager.register(FooFoo)
     oinfo = ip.object_inspect("foo")
     assert oinfo["found"] is True
     assert oinfo["ismagic"] is True
 
     oinfo = ip.object_inspect("%%foo")
     assert oinfo["found"] is True
     assert oinfo["ismagic"] is True
     assert oinfo["docstring"] == FooFoo.cell_foo.__doc__
 
     oinfo = ip.object_inspect("%foo")
     assert oinfo["found"] is True
     assert oinfo["ismagic"] is True
     assert oinfo["docstring"] == FooFoo.line_foo.__doc__
 
 
 def test_multiple_magics():
     ip = get_ipython()
     foo1 = FooFoo(ip)
     foo2 = FooFoo(ip)
     mm = ip.magics_manager
     mm.register(foo1)
     assert mm.magics["line"]["foo"].__self__ is foo1
     mm.register(foo2)
     assert mm.magics["line"]["foo"].__self__ is foo2
 
 
 def test_alias_magic():
     """Test %alias_magic."""
     ip = get_ipython()
     mm = ip.magics_manager
 
     # Basic operation: both cell and line magics are created, if possible.
     ip.run_line_magic("alias_magic", "timeit_alias timeit")
     assert "timeit_alias" in mm.magics["line"]
     assert "timeit_alias" in mm.magics["cell"]
 
     # --cell is specified, line magic not created.
     ip.run_line_magic("alias_magic", "--cell timeit_cell_alias timeit")
     assert "timeit_cell_alias" not in mm.magics["line"]
     assert "timeit_cell_alias" in mm.magics["cell"]
 
     # Test that line alias is created successfully.
     ip.run_line_magic("alias_magic", "--line env_alias env")
     assert ip.run_line_magic("env", "") == ip.run_line_magic("env_alias", "")
 
     # Test that line alias with parameters passed in is created successfully.
     ip.run_line_magic(
         "alias_magic", "--line history_alias history --params " + shlex.quote("3")
     )
     assert "history_alias" in mm.magics["line"]
 
 
 def test_save():
     """Test %save."""
     ip = get_ipython()
     ip.history_manager.reset()   # Clear any existing history.
     cmds = ["a=1", "def b():\n  return a**2", "print(a, b())"]
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
     with TemporaryDirectory() as tmpdir:
         file = os.path.join(tmpdir, "testsave.py")
         ip.run_line_magic("save", "%s 1-10" % file)
         content = Path(file).read_text(encoding="utf-8")
         assert content.count(cmds[0]) == 1
         assert "coding: utf-8" in content
         ip.run_line_magic("save", "-a %s 1-10" % file)
         content = Path(file).read_text(encoding="utf-8")
         assert content.count(cmds[0]) == 2
         assert "coding: utf-8" in content
 
 
 def test_save_with_no_args():
     ip = get_ipython()
     ip.history_manager.reset()  # Clear any existing history.
     cmds = ["a=1", "def b():\n    return a**2", "print(a, b())", "%save"]
     for i, cmd in enumerate(cmds, start=1):
         ip.history_manager.store_inputs(i, cmd)
 
     with TemporaryDirectory() as tmpdir:
         path = os.path.join(tmpdir, "testsave.py")
         ip.run_line_magic("save", path)
         content = Path(path).read_text(encoding="utf-8")
         expected_content = dedent(
             """\
             # coding: utf-8
             a=1
             def b():
                 return a**2
             print(a, b())
             """
         )
         assert content == expected_content
 
 
 def test_store():
     """Test %store."""
     ip = get_ipython()
     ip.run_line_magic('load_ext', 'storemagic')
 
     # make sure the storage is empty
     ip.run_line_magic("store", "-z")
     ip.user_ns["var"] = 42
     ip.run_line_magic("store", "var")
     ip.user_ns["var"] = 39
     ip.run_line_magic("store", "-r")
     assert ip.user_ns["var"] == 42
 
     ip.run_line_magic("store", "-d var")
     ip.user_ns["var"] = 39
     ip.run_line_magic("store", "-r")
     assert ip.user_ns["var"] == 39
 
 
 def _run_edit_test(arg_s, exp_filename=None,
                         exp_lineno=-1,
                         exp_contents=None,
                         exp_is_temp=None):
     ip = get_ipython()
     M = code.CodeMagics(ip)
     last_call = ['','']
     opts,args = M.parse_options(arg_s,'prxn:')
     filename, lineno, is_temp = M._find_edit_target(ip, args, opts, last_call)
 
     if exp_filename is not None:
         assert exp_filename == filename
     if exp_contents is not None:
         with io.open(filename, 'r', encoding='utf-8') as f:
             contents = f.read()
         assert exp_contents == contents
     if exp_lineno != -1:
         assert exp_lineno == lineno
     if exp_is_temp is not None:
         assert exp_is_temp == is_temp
 
 
 def test_edit_interactive():
     """%edit on interactively defined objects"""
     ip = get_ipython()
     n = ip.execution_count
     ip.run_cell("def foo(): return 1", store_history=True)
 
     with pytest.raises(code.InteractivelyDefined) as e:
         _run_edit_test("foo")
     assert e.value.index == n
 
 
 def test_edit_cell():
     """%edit [cell id]"""
     ip = get_ipython()
 
     ip.run_cell("def foo(): return 1", store_history=True)
 
     # test
     _run_edit_test("1", exp_contents=ip.user_ns['In'][1], exp_is_temp=True)
 
 def test_edit_fname():
     """%edit file"""
     # test
     _run_edit_test("test file.py", exp_filename="test file.py")
 
 def test_bookmark():
     ip = get_ipython()
     ip.run_line_magic('bookmark', 'bmname')
     with tt.AssertPrints('bmname'):
         ip.run_line_magic('bookmark', '-l')
     ip.run_line_magic('bookmark', '-d bmname')
 
 def test_ls_magic():
     ip = get_ipython()
     json_formatter = ip.display_formatter.formatters['application/json']
     json_formatter.enabled = True
     lsmagic = ip.magic('lsmagic')
     with warnings.catch_warnings(record=True) as w:
         j = json_formatter(lsmagic)
     assert sorted(j) == ["cell", "line"]
     assert w == []  # no warnings
 
 
 def test_strip_initial_indent():
     def sii(s):
         lines = s.splitlines()
         return '\n'.join(code.strip_initial_indent(lines))
 
     assert sii("  a = 1\nb = 2") == "a = 1\nb = 2"
     assert sii("  a\n    b\nc") == "a\n  b\nc"
     assert sii("a\n  b") == "a\n  b"
 
 def test_logging_magic_quiet_from_arg():
     _ip.config.LoggingMagics.quiet = False
     lm = logging.LoggingMagics(shell=_ip)
     with TemporaryDirectory() as td:
         try:
             with tt.AssertNotPrints(re.compile("Activating.*")):
                 lm.logstart('-q {}'.format(
                         os.path.join(td, "quiet_from_arg.log")))
         finally:
             _ip.logger.logstop()
 
 def test_logging_magic_quiet_from_config():
     _ip.config.LoggingMagics.quiet = True
     lm = logging.LoggingMagics(shell=_ip)
     with TemporaryDirectory() as td:
         try:
             with tt.AssertNotPrints(re.compile("Activating.*")):
                 lm.logstart(os.path.join(td, "quiet_from_config.log"))
         finally:
             _ip.logger.logstop()
 
 
 def test_logging_magic_not_quiet():
     _ip.config.LoggingMagics.quiet = False
     lm = logging.LoggingMagics(shell=_ip)
     with TemporaryDirectory() as td:
         try:
             with tt.AssertPrints(re.compile("Activating.*")):
                 lm.logstart(os.path.join(td, "not_quiet.log"))
         finally:
             _ip.logger.logstop()
 
 
 def test_time_no_var_expand():
     _ip.user_ns['a'] = 5
     _ip.user_ns['b'] = []
     _ip.magic('time b.append("{a}")')
     assert _ip.user_ns['b'] == ['{a}']
 
 
 # this is slow, put at the end for local testing.
 def test_timeit_arguments():
     "Test valid timeit arguments, should not cause SyntaxError (GH #1269)"
     _ip.magic("timeit -n1 -r1 a=('#')")
 
 
 MINIMAL_LAZY_MAGIC = """
 from IPython.core.magic import (
     Magics,
     magics_class,
     line_magic,
     cell_magic,
 )
 
 
 @magics_class
 class LazyMagics(Magics):
     @line_magic
     def lazy_line(self, line):
         print("Lazy Line")
 
     @cell_magic
     def lazy_cell(self, line, cell):
         print("Lazy Cell")
 
 
 def load_ipython_extension(ipython):
     ipython.register_magics(LazyMagics)
 """
 
 
 def test_lazy_magics():
     with pytest.raises(UsageError):
         ip.run_line_magic("lazy_line", "")
 
     startdir = os.getcwd()
 
     with TemporaryDirectory() as tmpdir:
         with prepended_to_syspath(tmpdir):
             ptempdir = Path(tmpdir)
             tf = ptempdir / "lazy_magic_module.py"
             tf.write_text(MINIMAL_LAZY_MAGIC)
             ip.magics_manager.register_lazy("lazy_line", Path(tf.name).name[:-3])
             with tt.AssertPrints("Lazy Line"):
                 ip.run_line_magic("lazy_line", "")
 
 
 TEST_MODULE = """
 print('Loaded my_tmp')
 if __name__ == "__main__":
     print('I just ran a script')
 """
 
 def test_run_module_from_import_hook():
     "Test that a module can be loaded via an import hook"
     with TemporaryDirectory() as tmpdir:
         fullpath = os.path.join(tmpdir, "my_tmp.py")
         Path(fullpath).write_text(TEST_MODULE, encoding="utf-8")
 
         import importlib.abc
         import importlib.util
 
         class MyTempImporter(importlib.abc.MetaPathFinder, importlib.abc.SourceLoader):
             def find_spec(self, fullname, path, target=None):
                 if fullname == "my_tmp":
                     return importlib.util.spec_from_loader(fullname, self)
 
             def get_filename(self, fullname):
                 assert fullname == "my_tmp"
                 return fullpath
 
             def get_data(self, path):
                 assert Path(path).samefile(fullpath)
                 return Path(fullpath).read_text(encoding="utf-8")
 
         sys.meta_path.insert(0, MyTempImporter())
 
         with capture_output() as captured:
             _ip.magic("run -m my_tmp")
             _ip.run_cell("import my_tmp")
 
         output = "Loaded my_tmp\nI just ran a script\nLoaded my_tmp\n"
         assert output == captured.stdout
 
         sys.meta_path.pop(0)

IPython/core/tests/test_magic_terminal.py

@@ -1,212 +1,216 b''
 """Tests for various magic functions specific to the terminal frontend."""
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 from io import StringIO
 from unittest import TestCase
 
 from IPython.testing import tools as tt
 #-----------------------------------------------------------------------------
 # Test functions begin
 #-----------------------------------------------------------------------------
 
 
 MINIMAL_LAZY_MAGIC = """
 from IPython.core.magic import (
     Magics,
     magics_class,
     line_magic,
     cell_magic,
 )
 
 
 @magics_class
 class LazyMagics(Magics):
     @line_magic
     def lazy_line(self, line):
         print("Lazy Line")
 
     @cell_magic
     def lazy_cell(self, line, cell):
         print("Lazy Cell")
 
 
 def load_ipython_extension(ipython):
     ipython.register_magics(LazyMagics)
 """
 
 def check_cpaste(code, should_fail=False):
     """Execute code via 'cpaste' and ensure it was executed, unless
     should_fail is set.
     """
     ip.user_ns['code_ran'] = False
 
     src = StringIO()
     src.write(code)
     src.write('\n--\n')
     src.seek(0)
 
     stdin_save = sys.stdin
     sys.stdin = src
 
     try:
         context = tt.AssertPrints if should_fail else tt.AssertNotPrints
         with context("Traceback (most recent call last)"):
             ip.run_line_magic("cpaste", "")
 
         if not should_fail:
             assert ip.user_ns['code_ran'], "%r failed" % code
     finally:
         sys.stdin = stdin_save
 
 def test_cpaste():
     """Test cpaste magic"""
 
     def runf():
         """Marker function: sets a flag when executed.
         """
         ip.user_ns['code_ran'] = True
         return 'runf' # return string so '+ runf()' doesn't result in success
 
     tests = {'pass': ["runf()",
                       "In [1]: runf()",
                       "In [1]: if 1:\n   ...:     runf()",
                       "> > > runf()",
                       ">>> runf()",
                       "   >>> runf()",
                       ],
 
              'fail': ["1 + runf()",
                       "++ runf()",
              ]}
 
     ip.user_ns['runf'] = runf
 
     for code in tests['pass']:
         check_cpaste(code)
 
     for code in tests['fail']:
         check_cpaste(code, should_fail=True)
 
 
 
 class PasteTestCase(TestCase):
     """Multiple tests for clipboard pasting"""
 
     def paste(self, txt, flags='-q'):
         """Paste input text, by default in quiet mode"""
         ip.hooks.clipboard_get = lambda: txt
         ip.run_line_magic("paste", flags)
 
     def setUp(self):
         # Inject fake clipboard hook but save original so we can restore it later
         self.original_clip = ip.hooks.clipboard_get
 
     def tearDown(self): 
         # Restore original hook
         ip.hooks.clipboard_get = self.original_clip
        
     def test_paste(self):
         ip.user_ns.pop("x", None)
         self.paste("x = 1")
         self.assertEqual(ip.user_ns["x"], 1)
         ip.user_ns.pop("x")
 
     def test_paste_pyprompt(self):
         ip.user_ns.pop("x", None)
         self.paste(">>> x=2")
         self.assertEqual(ip.user_ns["x"], 2)
         ip.user_ns.pop("x")
 
     def test_paste_py_multi(self):
-        self.paste("""
+        self.paste(
+            """
         >>> x = [1,2,3]
         >>> y = []
         >>> for i in x:
         ...     y.append(i**2)
         ... 
         """
         )
         self.assertEqual(ip.user_ns["x"], [1, 2, 3])
         self.assertEqual(ip.user_ns["y"], [1, 4, 9])
 
     def test_paste_py_multi_r(self):
         "Now, test that self.paste -r works"
         self.test_paste_py_multi()
         self.assertEqual(ip.user_ns.pop("x"), [1, 2, 3])
         self.assertEqual(ip.user_ns.pop("y"), [1, 4, 9])
         self.assertFalse("x" in ip.user_ns)
         ip.run_line_magic("paste", "-r")
         self.assertEqual(ip.user_ns["x"], [1, 2, 3])
         self.assertEqual(ip.user_ns["y"], [1, 4, 9])
 
     def test_paste_email(self):
         "Test pasting of email-quoted contents"
-        self.paste("""\
+        self.paste(
+            """\
         >> def foo(x):
         >>     return x + 1
         >> xx = foo(1.1)"""
         )
         self.assertEqual(ip.user_ns["xx"], 2.1)
 
     def test_paste_email2(self):
         "Email again; some programs add a space also at each quoting level"
-        self.paste("""\
+        self.paste(
+            """\
         > > def foo(x):
         > >     return x + 1
         > > yy = foo(2.1)     """
         )
         self.assertEqual(ip.user_ns["yy"], 3.1)
 
     def test_paste_email_py(self):
         "Email quoting of interactive input"
-        self.paste("""\
+        self.paste(
+            """\
         >> >>> def f(x):
         >> ...   return x+1
         >> ... 
         >> >>> zz = f(2.5)      """
         )
         self.assertEqual(ip.user_ns["zz"], 3.5)
 
     def test_paste_echo(self):
         "Also test self.paste echoing, by temporarily faking the writer"
         w = StringIO()
         old_write = sys.stdout.write
         sys.stdout.write = w.write
         code = """
         a = 100
         b = 200"""
         try:
             self.paste(code,'')
             out = w.getvalue()
         finally:
             sys.stdout.write = old_write
         self.assertEqual(ip.user_ns["a"], 100)
         self.assertEqual(ip.user_ns["b"], 200)
         assert out == code + "\n## -- End pasted text --\n"
 
     def test_paste_leading_commas(self):
         "Test multiline strings with leading commas"
         tm = ip.magics_manager.registry['TerminalMagics']
         s = '''\
 a = """
 ,1,2,3
 """'''
         ip.user_ns.pop("foo", None)
         tm.store_or_execute(s, "foo")
         self.assertIn("foo", ip.user_ns)
 
     def test_paste_trailing_question(self):
         "Test pasting sources with trailing question marks"
         tm = ip.magics_manager.registry['TerminalMagics']
         s = '''\
 def funcfoo():
    if True: #am i true?
        return 'fooresult'
 '''
         ip.user_ns.pop('funcfoo', None)
         self.paste(s)
         self.assertEqual(ip.user_ns["funcfoo"](), "fooresult")

IPython/core/tests/test_profile.py

@@ -1,155 +1,155 b''
 # coding: utf-8
 """Tests for profile-related functions.
 
 Currently only the startup-dir functionality is tested, but more tests should
 be added for:
 
     * ipython profile create
     * ipython profile list
     * ipython profile create --parallel
     * security dir permissions
 
 Authors
 -------
 
 * MinRK
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import shutil
 import sys
 import tempfile
 from pathlib import Path
 from unittest import TestCase
 
 from tempfile import TemporaryDirectory
 
 from IPython.core.profileapp import list_bundled_profiles, list_profiles_in
 from IPython.core.profiledir import ProfileDir
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 from IPython.utils.process import getoutput
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 TMP_TEST_DIR = Path(tempfile.mkdtemp())
 HOME_TEST_DIR = TMP_TEST_DIR / "home_test_dir"
 IP_TEST_DIR = HOME_TEST_DIR / ".ipython"
 
 #
 # Setup/teardown functions/decorators
 #
 
 def setup_module():
     """Setup test environment for the module:
 
             - Adds dummy home dir tree
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
     (Path.cwd() / IP_TEST_DIR).mkdir(parents=True)
 
 
 def teardown_module():
     """Teardown test environment for the module:
 
             - Remove dummy home dir tree
     """
     # Note: we remove the parent test dir, which is the root of all test
     # subdirs we may have created.  Use shutil instead of os.removedirs, so
     # that non-empty directories are all recursively removed.
     shutil.rmtree(TMP_TEST_DIR)
 
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 class ProfileStartupTest(TestCase):
     def setUp(self):
         # create profile dir
         self.pd = ProfileDir.create_profile_dir_by_name(IP_TEST_DIR, "test")
         self.options = ["--ipython-dir", IP_TEST_DIR, "--profile", "test"]
         self.fname = TMP_TEST_DIR / "test.py"
 
     def tearDown(self):
         # We must remove this profile right away so its presence doesn't
         # confuse other tests.
         shutil.rmtree(self.pd.location)
 
     def init(self, startup_file, startup, test):
         # write startup python file
         with open(Path(self.pd.startup_dir) / startup_file, "w", encoding="utf-8") as f:
             f.write(startup)
         # write simple test file, to check that the startup file was run
         with open(self.fname, "w", encoding="utf-8") as f:
             f.write(test)
 
     def validate(self, output):
         tt.ipexec_validate(self.fname, output, "", options=self.options)
 
     def test_startup_py(self):
         self.init('00-start.py', 'zzz=123\n', 'print(zzz)\n')
         self.validate('123')
 
     def test_startup_ipy(self):
         self.init('00-start.ipy', '%xmode plain\n', '')
         self.validate('Exception reporting mode: Plain')
 
 
 def test_list_profiles_in():
     # No need to remove these directories and files, as they will get nuked in
     # the module-level teardown.
     td = Path(tempfile.mkdtemp(dir=TMP_TEST_DIR))
     for name in ("profile_foo", "profile_hello", "not_a_profile"):
         Path(td / name).mkdir(parents=True)
     if dec.unicode_paths:
-        Path(td / u"profile_ünicode").mkdir(parents=True)
+        Path(td / "profile_ünicode").mkdir(parents=True)
 
     with open(td / "profile_file", "w", encoding="utf-8") as f:
         f.write("I am not a profile directory")
     profiles = list_profiles_in(td)
 
     # unicode normalization can turn u'ünicode' into u'u\0308nicode',
     # so only check for *nicode, and that creating a ProfileDir from the
     # name remains valid
     found_unicode = False
     for p in list(profiles):
         if p.endswith('nicode'):
             pd = ProfileDir.find_profile_dir_by_name(td, p)
             profiles.remove(p)
             found_unicode = True
             break
     if dec.unicode_paths:
         assert found_unicode is True
     assert set(profiles) == {"foo", "hello"}
 
 
 def test_list_bundled_profiles():
     # This variable will need to be updated when a new profile gets bundled
     bundled = sorted(list_bundled_profiles())
     assert bundled == []
 
 
 def test_profile_create_ipython_dir():
     """ipython profile create respects --ipython-dir"""
     with TemporaryDirectory() as td:
         getoutput(
             [
                 sys.executable,
                 "-m",
                 "IPython",
                 "profile",
                 "create",
                 "foo",
                 "--ipython-dir=%s" % td,
             ]
         )
         profile_dir = Path(td) / "profile_foo"
         assert Path(profile_dir).exists()
         ipython_config = profile_dir / "ipython_config.py"
         assert Path(ipython_config).exists()

IPython/external/qt_loaders.py

@@ -1,397 +1,399 b''
 """
 This module contains factory functions that attempt
 to return Qt submodules from the various python Qt bindings.
 
 It also protects against double-importing Qt with different
 bindings, which is unstable and likely to crash
 
 This is used primarily by qt and qt_for_kernel, and shouldn't
 be accessed directly from the outside
 """
 import importlib.abc
 import sys
 import types
 from functools import partial, lru_cache
 import operator
 
 # ### Available APIs.
 # Qt6
 QT_API_PYQT6 = "pyqt6"
 QT_API_PYSIDE6 = "pyside6"
 
 # Qt5
 QT_API_PYQT5 = 'pyqt5'
 QT_API_PYSIDE2 = 'pyside2'
 
 # Qt4
 QT_API_PYQT = "pyqt"  # Force version 2
 QT_API_PYQTv1 = "pyqtv1"  # Force version 2
 QT_API_PYSIDE = "pyside"
 
 QT_API_PYQT_DEFAULT = "pyqtdefault"  # use system default for version 1 vs. 2
 
 api_to_module = {
     # Qt6
     QT_API_PYQT6: "PyQt6",
     QT_API_PYSIDE6: "PySide6",
     # Qt5
     QT_API_PYQT5: "PyQt5",
     QT_API_PYSIDE2: "PySide2",
     # Qt4
     QT_API_PYSIDE: "PySide",
     QT_API_PYQT: "PyQt4",
     QT_API_PYQTv1: "PyQt4",
     # default
     QT_API_PYQT_DEFAULT: "PyQt6",
 }
 
 
 class ImportDenier(importlib.abc.MetaPathFinder):
     """Import Hook that will guard against bad Qt imports
     once IPython commits to a specific binding
     """
 
     def __init__(self):
         self.__forbidden = set()
 
     def forbid(self, module_name):
         sys.modules.pop(module_name, None)
         self.__forbidden.add(module_name)
 
     def find_spec(self, fullname, path, target=None):
         if path:
             return
         if fullname in self.__forbidden:
             raise ImportError(
                 """
     Importing %s disabled by IPython, which has
     already imported an Incompatible QT Binding: %s
-    """ % (fullname, loaded_api()))
+    """
+                % (fullname, loaded_api())
+            )
 
 
 ID = ImportDenier()
 sys.meta_path.insert(0, ID)
 
 
 def commit_api(api):
     """Commit to a particular API, and trigger ImportErrors on subsequent
     dangerous imports"""
     modules = set(api_to_module.values())
 
     modules.remove(api_to_module[api])
     for mod in modules:
         ID.forbid(mod)
 
 
 def loaded_api():
     """Return which API is loaded, if any
 
     If this returns anything besides None,
     importing any other Qt binding is unsafe.
 
     Returns
     -------
     None, 'pyside6', 'pyqt6', 'pyside2', 'pyside', 'pyqt', 'pyqt5', 'pyqtv1'
     """
     if sys.modules.get("PyQt6.QtCore"):
         return QT_API_PYQT6
     elif sys.modules.get("PySide6.QtCore"):
         return QT_API_PYSIDE6
     elif sys.modules.get("PyQt5.QtCore"):
         return QT_API_PYQT5
     elif sys.modules.get("PySide2.QtCore"):
         return QT_API_PYSIDE2
     elif sys.modules.get("PyQt4.QtCore"):
         if qtapi_version() == 2:
             return QT_API_PYQT
         else:
             return QT_API_PYQTv1
     elif sys.modules.get("PySide.QtCore"):
         return QT_API_PYSIDE
 
     return None
 
 
 def has_binding(api):
     """Safely check for PyQt4/5, PySide or PySide2, without importing submodules
 
     Parameters
     ----------
     api : str [ 'pyqtv1' | 'pyqt' | 'pyqt5' | 'pyside' | 'pyside2' | 'pyqtdefault']
         Which module to check for
 
     Returns
     -------
     True if the relevant module appears to be importable
     """
     module_name = api_to_module[api]
     from importlib.util import find_spec
 
     required = ['QtCore', 'QtGui', 'QtSvg']
     if api in (QT_API_PYQT5, QT_API_PYSIDE2, QT_API_PYQT6, QT_API_PYSIDE6):
         # QT5 requires QtWidgets too
         required.append('QtWidgets')
 
     for submod in required:
         try:
             spec = find_spec('%s.%s' % (module_name, submod))
         except ImportError:
             # Package (e.g. PyQt5) not found
             return False
         else:
             if spec is None:
                 # Submodule (e.g. PyQt5.QtCore) not found
                 return False
 
     if api == QT_API_PYSIDE:
         # We can also safely check PySide version
         import PySide
 
         return PySide.__version_info__ >= (1, 0, 3)
 
     return True
 
 
 def qtapi_version():
     """Return which QString API has been set, if any
 
     Returns
     -------
     The QString API version (1 or 2), or None if not set
     """
     try:
         import sip
     except ImportError:
         # as of PyQt5 5.11, sip is no longer available as a top-level
         # module and needs to be imported from the PyQt5 namespace
         try:
             from PyQt5 import sip
         except ImportError:
             return
     try:
         return sip.getapi('QString')
     except ValueError:
         return
 
 
 def can_import(api):
     """Safely query whether an API is importable, without importing it"""
     if not has_binding(api):
         return False
 
     current = loaded_api()
     if api == QT_API_PYQT_DEFAULT:
         return current in [QT_API_PYQT6, None]
     else:
         return current in [api, None]
 
 
 def import_pyqt4(version=2):
     """
     Import PyQt4
 
     Parameters
     ----------
     version : 1, 2, or None
         Which QString/QVariant API to use. Set to None to use the system
         default
     ImportErrors raised within this function are non-recoverable
     """
     # The new-style string API (version=2) automatically
     # converts QStrings to Unicode Python strings. Also, automatically unpacks
     # QVariants to their underlying objects.
     import sip
 
     if version is not None:
         sip.setapi('QString', version)
         sip.setapi('QVariant', version)
 
     from PyQt4 import QtGui, QtCore, QtSvg
 
     if QtCore.PYQT_VERSION < 0x040700:
         raise ImportError("IPython requires PyQt4 >= 4.7, found %s" %
                           QtCore.PYQT_VERSION_STR)
 
     # Alias PyQt-specific functions for PySide compatibility.
     QtCore.Signal = QtCore.pyqtSignal
     QtCore.Slot = QtCore.pyqtSlot
 
     # query for the API version (in case version == None)
     version = sip.getapi('QString')
     api = QT_API_PYQTv1 if version == 1 else QT_API_PYQT
     return QtCore, QtGui, QtSvg, api
 
 
 def import_pyqt5():
     """
     Import PyQt5
 
     ImportErrors raised within this function are non-recoverable
     """
 
     from PyQt5 import QtCore, QtSvg, QtWidgets, QtGui
 
     # Alias PyQt-specific functions for PySide compatibility.
     QtCore.Signal = QtCore.pyqtSignal
     QtCore.Slot = QtCore.pyqtSlot
 
     # Join QtGui and QtWidgets for Qt4 compatibility.
     QtGuiCompat = types.ModuleType('QtGuiCompat')
     QtGuiCompat.__dict__.update(QtGui.__dict__)
     QtGuiCompat.__dict__.update(QtWidgets.__dict__)
 
     api = QT_API_PYQT5
     return QtCore, QtGuiCompat, QtSvg, api
 
 
 def import_pyqt6():
     """
     Import PyQt6
 
     ImportErrors raised within this function are non-recoverable
     """
 
     from PyQt6 import QtCore, QtSvg, QtWidgets, QtGui
 
     # Alias PyQt-specific functions for PySide compatibility.
     QtCore.Signal = QtCore.pyqtSignal
     QtCore.Slot = QtCore.pyqtSlot
 
     # Join QtGui and QtWidgets for Qt4 compatibility.
     QtGuiCompat = types.ModuleType("QtGuiCompat")
     QtGuiCompat.__dict__.update(QtGui.__dict__)
     QtGuiCompat.__dict__.update(QtWidgets.__dict__)
 
     api = QT_API_PYQT6
     return QtCore, QtGuiCompat, QtSvg, api
 
 
 def import_pyside():
     """
     Import PySide
 
     ImportErrors raised within this function are non-recoverable
     """
     from PySide import QtGui, QtCore, QtSvg
     return QtCore, QtGui, QtSvg, QT_API_PYSIDE
 
 def import_pyside2():
     """
     Import PySide2
 
     ImportErrors raised within this function are non-recoverable
     """
     from PySide2 import QtGui, QtCore, QtSvg, QtWidgets, QtPrintSupport
 
     # Join QtGui and QtWidgets for Qt4 compatibility.
     QtGuiCompat = types.ModuleType('QtGuiCompat')
     QtGuiCompat.__dict__.update(QtGui.__dict__)
     QtGuiCompat.__dict__.update(QtWidgets.__dict__)
     QtGuiCompat.__dict__.update(QtPrintSupport.__dict__)
 
     return QtCore, QtGuiCompat, QtSvg, QT_API_PYSIDE2
 
 
 def import_pyside6():
     """
     Import PySide6
 
     ImportErrors raised within this function are non-recoverable
     """
     from PySide6 import QtGui, QtCore, QtSvg, QtWidgets, QtPrintSupport
 
     # Join QtGui and QtWidgets for Qt4 compatibility.
     QtGuiCompat = types.ModuleType("QtGuiCompat")
     QtGuiCompat.__dict__.update(QtGui.__dict__)
     QtGuiCompat.__dict__.update(QtWidgets.__dict__)
     QtGuiCompat.__dict__.update(QtPrintSupport.__dict__)
 
     return QtCore, QtGuiCompat, QtSvg, QT_API_PYSIDE6
 
 
 def load_qt(api_options):
     """
     Attempt to import Qt, given a preference list
     of permissible bindings
 
     It is safe to call this function multiple times.
 
     Parameters
     ----------
     api_options : List of strings
         The order of APIs to try. Valid items are 'pyside', 'pyside2',
         'pyqt', 'pyqt5', 'pyqtv1' and 'pyqtdefault'
 
     Returns
     -------
     A tuple of QtCore, QtGui, QtSvg, QT_API
     The first three are the Qt modules. The last is the
     string indicating which module was loaded.
 
     Raises
     ------
     ImportError, if it isn't possible to import any requested
     bindings (either because they aren't installed, or because
     an incompatible library has already been installed)
     """
     loaders = {
         # Qt6
         QT_API_PYQT6: import_pyqt6,
         QT_API_PYSIDE6: import_pyside6,
         # Qt5
         QT_API_PYQT5: import_pyqt5,
         QT_API_PYSIDE2: import_pyside2,
         # Qt4
         QT_API_PYSIDE: import_pyside,
         QT_API_PYQT: import_pyqt4,
         QT_API_PYQTv1: partial(import_pyqt4, version=1),
         # default
         QT_API_PYQT_DEFAULT: import_pyqt6,
     }
 
     for api in api_options:
 
         if api not in loaders:
             raise RuntimeError(
                 "Invalid Qt API %r, valid values are: %s" %
                 (api, ", ".join(["%r" % k for k in loaders.keys()])))
 
         if not can_import(api):
             continue
 
         #cannot safely recover from an ImportError during this
         result = loaders[api]()
         api = result[-1]  # changed if api = QT_API_PYQT_DEFAULT
         commit_api(api)
         return result
     else:
         raise ImportError("""
     Could not load requested Qt binding. Please ensure that
     PyQt4 >= 4.7, PyQt5, PySide >= 1.0.3 or PySide2 is available,
     and only one is imported per session.
 
     Currently-imported Qt library:                              %r
     PyQt4 available (requires QtCore, QtGui, QtSvg):            %s
     PyQt5 available (requires QtCore, QtGui, QtSvg, QtWidgets): %s
     PySide >= 1.0.3 installed:                                  %s
     PySide2 installed:                                          %s
     Tried to load:                                              %r
     """ % (loaded_api(),
            has_binding(QT_API_PYQT),
            has_binding(QT_API_PYQT5),
            has_binding(QT_API_PYSIDE),
            has_binding(QT_API_PYSIDE2),
            api_options))
 
 
 def enum_factory(QT_API, QtCore):
     """Construct an enum helper to account for PyQt5 <-> PyQt6 changes."""
 
     @lru_cache(None)
     def _enum(name):
         # foo.bar.Enum.Entry (PyQt6) <=> foo.bar.Entry (non-PyQt6).
         return operator.attrgetter(
             name if QT_API == QT_API_PYQT6 else name.rpartition(".")[0]
         )(sys.modules[QtCore.__package__])
 
     return _enum

IPython/lib/display.py

@@ -1,677 +1,675 b''
 """Various display related classes.
 
 Authors : MinRK, gregcaporaso, dannystaple
 """
 from html import escape as html_escape
 from os.path import exists, isfile, splitext, abspath, join, isdir
 from os import walk, sep, fsdecode
 
 from IPython.core.display import DisplayObject, TextDisplayObject
 
 from typing import Tuple, Iterable
 
 __all__ = ['Audio', 'IFrame', 'YouTubeVideo', 'VimeoVideo', 'ScribdDocument',
            'FileLink', 'FileLinks', 'Code']
 
 
 class Audio(DisplayObject):
     """Create an audio object.
 
     When this object is returned by an input cell or passed to the
     display function, it will result in Audio controls being displayed
     in the frontend (only works in the notebook).
 
     Parameters
     ----------
     data : numpy array, list, unicode, str or bytes
         Can be one of
 
           * Numpy 1d array containing the desired waveform (mono)
           * Numpy 2d array containing waveforms for each channel.
             Shape=(NCHAN, NSAMPLES). For the standard channel order, see
             http://msdn.microsoft.com/en-us/library/windows/hardware/dn653308(v=vs.85).aspx
           * List of float or integer representing the waveform (mono)
           * String containing the filename
           * Bytestring containing raw PCM data or
           * URL pointing to a file on the web.
 
         If the array option is used, the waveform will be normalized.
 
         If a filename or url is used, the format support will be browser
         dependent.
     url : unicode
         A URL to download the data from.
     filename : unicode
         Path to a local file to load the data from.
     embed : boolean
         Should the audio data be embedded using a data URI (True) or should
         the original source be referenced. Set this to True if you want the
         audio to playable later with no internet connection in the notebook.
 
         Default is `True`, unless the keyword argument `url` is set, then
         default value is `False`.
     rate : integer
         The sampling rate of the raw data.
         Only required when data parameter is being used as an array
     autoplay : bool
         Set to True if the audio should immediately start playing.
         Default is `False`.
     normalize : bool
         Whether audio should be normalized (rescaled) to the maximum possible
         range. Default is `True`. When set to `False`, `data` must be between
         -1 and 1 (inclusive), otherwise an error is raised.
         Applies only when `data` is a list or array of samples; other types of
         audio are never normalized.
 
     Examples
     --------
 
     >>> import pytest
     >>> np = pytest.importorskip("numpy")
 
     Generate a sound
 
     >>> import numpy as np
     >>> framerate = 44100
     >>> t = np.linspace(0,5,framerate*5)
     >>> data = np.sin(2*np.pi*220*t) + np.sin(2*np.pi*224*t)
     >>> Audio(data, rate=framerate)
     <IPython.lib.display.Audio object>
 
     Can also do stereo or more channels
 
     >>> dataleft = np.sin(2*np.pi*220*t)
     >>> dataright = np.sin(2*np.pi*224*t)
     >>> Audio([dataleft, dataright], rate=framerate)
     <IPython.lib.display.Audio object>
 
     From URL:
 
     >>> Audio("http://www.nch.com.au/acm/8k16bitpcm.wav")  # doctest: +SKIP
     >>> Audio(url="http://www.w3schools.com/html/horse.ogg")  # doctest: +SKIP
 
     From a File:
 
     >>> Audio('IPython/lib/tests/test.wav')  # doctest: +SKIP
     >>> Audio(filename='IPython/lib/tests/test.wav')  # doctest: +SKIP
 
     From Bytes:
 
     >>> Audio(b'RAW_WAV_DATA..')  # doctest: +SKIP
     >>> Audio(data=b'RAW_WAV_DATA..')  # doctest: +SKIP
 
     See Also
     --------
     ipywidgets.Audio
     
-         AUdio widget with more more flexibility and options.
+         Audio widget with more more flexibility and options.
     
     """
     _read_flags = 'rb'
 
     def __init__(self, data=None, filename=None, url=None, embed=None, rate=None, autoplay=False, normalize=True, *,
                  element_id=None):
         if filename is None and url is None and data is None:
             raise ValueError("No audio data found. Expecting filename, url, or data.")
         if embed is False and url is None:
             raise ValueError("No url found. Expecting url when embed=False")
 
         if url is not None and embed is not True:
             self.embed = False
         else:
             self.embed = True
         self.autoplay = autoplay
         self.element_id = element_id
         super(Audio, self).__init__(data=data, url=url, filename=filename)
 
         if self.data is not None and not isinstance(self.data, bytes):
             if rate is None:
                 raise ValueError("rate must be specified when data is a numpy array or list of audio samples.")
             self.data = Audio._make_wav(data, rate, normalize)
 
     def reload(self):
         """Reload the raw data from file or URL."""
         import mimetypes
         if self.embed:
             super(Audio, self).reload()
 
         if self.filename is not None:
             self.mimetype = mimetypes.guess_type(self.filename)[0]
         elif self.url is not None:
             self.mimetype = mimetypes.guess_type(self.url)[0]
         else:
             self.mimetype = "audio/wav"
 
     @staticmethod
     def _make_wav(data, rate, normalize):
         """ Transform a numpy array to a PCM bytestring """
         from io import BytesIO
         import wave
 
         try:
             scaled, nchan = Audio._validate_and_normalize_with_numpy(data, normalize)
         except ImportError:
             scaled, nchan = Audio._validate_and_normalize_without_numpy(data, normalize)
 
         fp = BytesIO()
         waveobj = wave.open(fp,mode='wb')
         waveobj.setnchannels(nchan)
         waveobj.setframerate(rate)
         waveobj.setsampwidth(2)
         waveobj.setcomptype('NONE','NONE')
         waveobj.writeframes(scaled)
         val = fp.getvalue()
         waveobj.close()
 
         return val
 
     @staticmethod
     def _validate_and_normalize_with_numpy(data, normalize) -> Tuple[bytes, int]:
         import numpy as np
 
         data = np.array(data, dtype=float)
         if len(data.shape) == 1:
             nchan = 1
         elif len(data.shape) == 2:
             # In wave files,channels are interleaved. E.g.,
             # "L1R1L2R2..." for stereo. See
             # http://msdn.microsoft.com/en-us/library/windows/hardware/dn653308(v=vs.85).aspx
             # for channel ordering
             nchan = data.shape[0]
             data = data.T.ravel()
         else:
             raise ValueError('Array audio input must be a 1D or 2D array')
         
         max_abs_value = np.max(np.abs(data))
         normalization_factor = Audio._get_normalization_factor(max_abs_value, normalize)
         scaled = data / normalization_factor * 32767
         return scaled.astype("<h").tobytes(), nchan
 
     @staticmethod
     def _validate_and_normalize_without_numpy(data, normalize):
         import array
         import sys
 
         data = array.array('f', data)
 
         try:
             max_abs_value = float(max([abs(x) for x in data]))
         except TypeError as e:
             raise TypeError('Only lists of mono audio are '
                 'supported if numpy is not installed') from e
 
         normalization_factor = Audio._get_normalization_factor(max_abs_value, normalize)
         scaled = array.array('h', [int(x / normalization_factor * 32767) for x in data])
         if sys.byteorder == 'big':
             scaled.byteswap()
         nchan = 1
         return scaled.tobytes(), nchan
 
     @staticmethod
     def _get_normalization_factor(max_abs_value, normalize):
         if not normalize and max_abs_value > 1:
             raise ValueError('Audio data must be between -1 and 1 when normalize=False.')
         return max_abs_value if normalize else 1
 
     def _data_and_metadata(self):
         """shortcut for returning metadata with url information, if defined"""
         md = {}
         if self.url:
             md['url'] = self.url
         if md:
             return self.data, md
         else:
             return self.data
 
     def _repr_html_(self):
         src = """
                 <audio {element_id} controls="controls" {autoplay}>
                     <source src="{src}" type="{type}" />
                     Your browser does not support the audio element.
                 </audio>
               """
         return src.format(src=self.src_attr(), type=self.mimetype, autoplay=self.autoplay_attr(),
                           element_id=self.element_id_attr())
 
     def src_attr(self):
         import base64
         if self.embed and (self.data is not None):
             data = base64=base64.b64encode(self.data).decode('ascii')
             return """data:{type};base64,{base64}""".format(type=self.mimetype,
                                                             base64=data)
         elif self.url is not None:
             return self.url
         else:
             return ""
 
     def autoplay_attr(self):
         if(self.autoplay):
             return 'autoplay="autoplay"'
         else:
             return ''
     
     def element_id_attr(self):
         if (self.element_id):
             return 'id="{element_id}"'.format(element_id=self.element_id)
         else:
             return ''
 
 class IFrame(object):
     """
     Generic class to embed an iframe in an IPython notebook
     """
 
     iframe = """
         <iframe
             width="{width}"
             height="{height}"
             src="{src}{params}"
             frameborder="0"
             allowfullscreen
             {extras}
         ></iframe>
         """
 
     def __init__(self, src, width, height, extras: Iterable[str] = None, **kwargs):
         if extras is None:
             extras = []
 
         self.src = src
         self.width = width
         self.height = height
         self.extras = extras
         self.params = kwargs
 
     def _repr_html_(self):
         """return the embed iframe"""
         if self.params:
             from urllib.parse import urlencode
             params = "?" + urlencode(self.params)
         else:
             params = ""
         return self.iframe.format(
             src=self.src,
             width=self.width,
             height=self.height,
             params=params,
             extras=" ".join(self.extras),
         )
 
 
 class YouTubeVideo(IFrame):
     """Class for embedding a YouTube Video in an IPython session, based on its video id.
 
     e.g. to embed the video from https://www.youtube.com/watch?v=foo , you would
     do::
 
         vid = YouTubeVideo("foo")
         display(vid)
 
     To start from 30 seconds::
 
         vid = YouTubeVideo("abc", start=30)
         display(vid)
 
     To calculate seconds from time as hours, minutes, seconds use
     :class:`datetime.timedelta`::
 
         start=int(timedelta(hours=1, minutes=46, seconds=40).total_seconds())
 
     Other parameters can be provided as documented at
     https://developers.google.com/youtube/player_parameters#Parameters
     
     When converting the notebook using nbconvert, a jpeg representation of the video
     will be inserted in the document.
     """
 
     def __init__(self, id, width=400, height=300, allow_autoplay=False, **kwargs):
         self.id=id
         src = "https://www.youtube.com/embed/{0}".format(id)
         if allow_autoplay:
             extras = list(kwargs.get("extras", [])) + ['allow="autoplay"']
             kwargs.update(autoplay=1, extras=extras)
         super(YouTubeVideo, self).__init__(src, width, height, **kwargs)
 
     def _repr_jpeg_(self):
         # Deferred import
         from urllib.request import urlopen
 
         try:
             return urlopen("https://img.youtube.com/vi/{id}/hqdefault.jpg".format(id=self.id)).read()
         except IOError:
             return None
 
 class VimeoVideo(IFrame):
     """
     Class for embedding a Vimeo video in an IPython session, based on its video id.
     """
 
     def __init__(self, id, width=400, height=300, **kwargs):
         src="https://player.vimeo.com/video/{0}".format(id)
         super(VimeoVideo, self).__init__(src, width, height, **kwargs)
 
 class ScribdDocument(IFrame):
     """
     Class for embedding a Scribd document in an IPython session
 
     Use the start_page params to specify a starting point in the document
     Use the view_mode params to specify display type one off scroll | slideshow | book
 
     e.g to Display Wes' foundational paper about PANDAS in book mode from page 3
 
     ScribdDocument(71048089, width=800, height=400, start_page=3, view_mode="book")
     """
 
     def __init__(self, id, width=400, height=300, **kwargs):
         src="https://www.scribd.com/embeds/{0}/content".format(id)
         super(ScribdDocument, self).__init__(src, width, height, **kwargs)
 
 class FileLink(object):
     """Class for embedding a local file link in an IPython session, based on path
 
     e.g. to embed a link that was generated in the IPython notebook as my/data.txt
 
     you would do::
 
         local_file = FileLink("my/data.txt")
         display(local_file)
 
     or in the HTML notebook, just::
 
         FileLink("my/data.txt")
     """
 
     html_link_str = "<a href='%s' target='_blank'>%s</a>"
 
     def __init__(self,
                  path,
                  url_prefix='',
                  result_html_prefix='',
                  result_html_suffix='<br>'):
         """
         Parameters
         ----------
         path : str
             path to the file or directory that should be formatted
         url_prefix : str
             prefix to be prepended to all files to form a working link [default:
             '']
         result_html_prefix : str
             text to append to beginning to link [default: '']
         result_html_suffix : str
             text to append at the end of link [default: '<br>']
         """
         if isdir(path):
             raise ValueError("Cannot display a directory using FileLink. "
               "Use FileLinks to display '%s'." % path)
         self.path = fsdecode(path)
         self.url_prefix = url_prefix
         self.result_html_prefix = result_html_prefix
         self.result_html_suffix = result_html_suffix
 
     def _format_path(self):
         fp = ''.join([self.url_prefix, html_escape(self.path)])
         return ''.join([self.result_html_prefix,
                         self.html_link_str % \
                             (fp, html_escape(self.path, quote=False)),
                         self.result_html_suffix])
 
     def _repr_html_(self):
         """return html link to file
         """
         if not exists(self.path):
             return ("Path (<tt>%s</tt>) doesn't exist. "
                     "It may still be in the process of "
                     "being generated, or you may have the "
                     "incorrect path." % self.path)
 
         return self._format_path()
 
     def __repr__(self):
         """return absolute path to file
         """
         return abspath(self.path)
 
 class FileLinks(FileLink):
     """Class for embedding local file links in an IPython session, based on path
 
     e.g. to embed links to files that were generated in the IPython notebook
     under ``my/data``, you would do::
 
         local_files = FileLinks("my/data")
         display(local_files)
 
     or in the HTML notebook, just::
 
         FileLinks("my/data")
     """
     def __init__(self,
                  path,
                  url_prefix='',
                  included_suffixes=None,
                  result_html_prefix='',
                  result_html_suffix='<br>',
                  notebook_display_formatter=None,
                  terminal_display_formatter=None,
                  recursive=True):
         """
         See :class:`FileLink` for the ``path``, ``url_prefix``,
         ``result_html_prefix`` and ``result_html_suffix`` parameters.
 
         included_suffixes : list
           Filename suffixes to include when formatting output [default: include
           all files]
 
         notebook_display_formatter : function
           Used to format links for display in the notebook. See discussion of
           formatter functions below.
 
         terminal_display_formatter : function
           Used to format links for display in the terminal. See discussion of
           formatter functions below.
 
         Formatter functions must be of the form::
 
             f(dirname, fnames, included_suffixes)
 
         dirname : str
           The name of a directory
         fnames : list
           The files in that directory
         included_suffixes : list
           The file suffixes that should be included in the output (passing None
           meansto include all suffixes in the output in the built-in formatters)
         recursive : boolean
           Whether to recurse into subdirectories. Default is True.
 
         The function should return a list of lines that will be printed in the
         notebook (if passing notebook_display_formatter) or the terminal (if
         passing terminal_display_formatter). This function is iterated over for
         each directory in self.path. Default formatters are in place, can be
         passed here to support alternative formatting.
 
         """
         if isfile(path):
             raise ValueError("Cannot display a file using FileLinks. "
               "Use FileLink to display '%s'." % path)
         self.included_suffixes = included_suffixes
         # remove trailing slashes for more consistent output formatting
         path = path.rstrip('/')
 
         self.path = path
         self.url_prefix = url_prefix
         self.result_html_prefix = result_html_prefix
         self.result_html_suffix = result_html_suffix
 
         self.notebook_display_formatter = \
              notebook_display_formatter or self._get_notebook_display_formatter()
         self.terminal_display_formatter = \
              terminal_display_formatter or self._get_terminal_display_formatter()
 
         self.recursive = recursive
 
-    def _get_display_formatter(self,
-                               dirname_output_format,
-                               fname_output_format,
-                               fp_format,
-                               fp_cleaner=None):
+    def _get_display_formatter(
+        self, dirname_output_format, fname_output_format, fp_format, fp_cleaner=None
+    ):
         """ generate built-in formatter function
 
         this is used to define both the notebook and terminal built-in
          formatters as they only differ by some wrapper text for each entry
 
         dirname_output_format: string to use for formatting directory
          names, dirname will be substituted for a single "%s" which
          must appear in this string
         fname_output_format: string to use for formatting file names,
          if a single "%s" appears in the string, fname will be substituted
          if two "%s" appear in the string, the path to fname will be
           substituted for the first and fname will be substituted for the
           second
         fp_format: string to use for formatting filepaths, must contain
          exactly two "%s" and the dirname will be substituted for the first
          and fname will be substituted for the second
         """
         def f(dirname, fnames, included_suffixes=None):
             result = []
             # begin by figuring out which filenames, if any,
             # are going to be displayed
             display_fnames = []
             for fname in fnames:
                 if (isfile(join(dirname,fname)) and
                        (included_suffixes is None or
                         splitext(fname)[1] in included_suffixes)):
                       display_fnames.append(fname)
 
             if len(display_fnames) == 0:
                 # if there are no filenames to display, don't print anything
                 # (not even the directory name)
                 pass
             else:
                 # otherwise print the formatted directory name followed by
                 # the formatted filenames
                 dirname_output_line = dirname_output_format % dirname
                 result.append(dirname_output_line)
                 for fname in display_fnames:
                     fp = fp_format % (dirname,fname)
                     if fp_cleaner is not None:
                         fp = fp_cleaner(fp)
                     try:
                         # output can include both a filepath and a filename...
                         fname_output_line = fname_output_format % (fp, fname)
                     except TypeError:
                         # ... or just a single filepath
                         fname_output_line = fname_output_format % fname
                     result.append(fname_output_line)
             return result
         return f
 
     def _get_notebook_display_formatter(self,
                                         spacer="&nbsp;&nbsp;"):
         """ generate function to use for notebook formatting
         """
         dirname_output_format = \
          self.result_html_prefix + "%s/" + self.result_html_suffix
         fname_output_format = \
          self.result_html_prefix + spacer + self.html_link_str + self.result_html_suffix
         fp_format = self.url_prefix + '%s/%s'
         if sep == "\\":
             # Working on a platform where the path separator is "\", so
             # must convert these to "/" for generating a URI
             def fp_cleaner(fp):
                 # Replace all occurrences of backslash ("\") with a forward
                 # slash ("/") - this is necessary on windows when a path is
                 # provided as input, but we must link to a URI
                 return fp.replace('\\','/')
         else:
             fp_cleaner = None
 
         return self._get_display_formatter(dirname_output_format,
                                            fname_output_format,
                                            fp_format,
                                            fp_cleaner)
 
     def _get_terminal_display_formatter(self,
                                         spacer="  "):
         """ generate function to use for terminal formatting
         """
         dirname_output_format = "%s/"
         fname_output_format = spacer + "%s"
         fp_format = '%s/%s'
 
         return self._get_display_formatter(dirname_output_format,
                                            fname_output_format,
                                            fp_format)
 
     def _format_path(self):
         result_lines = []
         if self.recursive:
             walked_dir = list(walk(self.path))
         else:
             walked_dir = [next(walk(self.path))]
         walked_dir.sort()
         for dirname, subdirs, fnames in walked_dir:
             result_lines += self.notebook_display_formatter(dirname, fnames, self.included_suffixes)
         return '\n'.join(result_lines)
 
     def __repr__(self):
         """return newline-separated absolute paths
         """
         result_lines = []
         if self.recursive:
             walked_dir = list(walk(self.path))
         else:
             walked_dir = [next(walk(self.path))]
         walked_dir.sort()
         for dirname, subdirs, fnames in walked_dir:
             result_lines += self.terminal_display_formatter(dirname, fnames, self.included_suffixes)
         return '\n'.join(result_lines)
 
 
 class Code(TextDisplayObject):
     """Display syntax-highlighted source code.
 
     This uses Pygments to highlight the code for HTML and Latex output.
 
     Parameters
     ----------
     data : str
         The code as a string
     url : str
         A URL to fetch the code from
     filename : str
         A local filename to load the code from
     language : str
         The short name of a Pygments lexer to use for highlighting.
         If not specified, it will guess the lexer based on the filename
         or the code. Available lexers: http://pygments.org/docs/lexers/
     """
     def __init__(self, data=None, url=None, filename=None, language=None):
         self.language = language
         super().__init__(data=data, url=url, filename=filename)
 
     def _get_lexer(self):
         if self.language:
             from pygments.lexers import get_lexer_by_name
             return get_lexer_by_name(self.language)
         elif self.filename:
             from pygments.lexers import get_lexer_for_filename
             return get_lexer_for_filename(self.filename)
         else:
             from pygments.lexers import guess_lexer
             return guess_lexer(self.data)
 
     def __repr__(self):
         return self.data
 
     def _repr_html_(self):
         from pygments import highlight
         from pygments.formatters import HtmlFormatter
         fmt = HtmlFormatter()
         style = '<style>{}</style>'.format(fmt.get_style_defs('.output_html'))
         return style + highlight(self.data, self._get_lexer(), fmt)
 
     def _repr_latex_(self):
         from pygments import highlight
         from pygments.formatters import LatexFormatter
         return highlight(self.data, self._get_lexer(), LatexFormatter())

IPython/lib/tests/test_latextools.py

@@ -1,192 +1,192 b''
 """Tests for IPython.utils.path.py"""
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from contextlib import contextmanager
 from unittest.mock import patch
 
 import pytest
 
 from IPython.lib import latextools
 from IPython.testing.decorators import (
     onlyif_cmds_exist,
     skipif_not_matplotlib,
 )
 from IPython.utils.process import FindCmdError
 
 
 @pytest.mark.parametrize('command', ['latex', 'dvipng'])
 def test_check_latex_to_png_dvipng_fails_when_no_cmd(command):
     def mock_find_cmd(arg):
         if arg == command:
             raise FindCmdError
 
     with patch.object(latextools, "find_cmd", mock_find_cmd):
         assert latextools.latex_to_png_dvipng("whatever", True) is None
 
 
 @contextmanager
 def no_op(*args, **kwargs):
     yield
 
 
 @onlyif_cmds_exist("latex", "dvipng")
[e-mail]("s, wrap", [(u"$$x^2$$", False), (u"x^2", True)])
[e-mail]("s, wrap", [("$$x^2$$", False), ("x^2", True)])
 def test_latex_to_png_dvipng_runs(s, wrap):
     """
     Test that latex_to_png_dvipng just runs without error.
     """
     def mock_kpsewhich(filename):
         assert filename == "breqn.sty"
         return None
 
     latextools.latex_to_png_dvipng(s, wrap)
 
     with patch_latextool(mock_kpsewhich):
         latextools.latex_to_png_dvipng(s, wrap)
 
 
 def mock_kpsewhich(filename):
     assert filename == "breqn.sty"
     return None
 
 @contextmanager
 def patch_latextool(mock=mock_kpsewhich):
     with patch.object(latextools, "kpsewhich", mock):
         yield
 
 @pytest.mark.parametrize('context', [no_op, patch_latextool])
 @pytest.mark.parametrize('s_wrap', [("$x^2$", False), ("x^2", True)])
 def test_latex_to_png_mpl_runs(s_wrap, context):
     """
     Test that latex_to_png_mpl just runs without error.
     """
     try:
         import matplotlib
     except ImportError:
         pytest.skip("This needs matplotlib to be available")
         return
     s, wrap = s_wrap
     with context():
         latextools.latex_to_png_mpl(s, wrap)
 
 @skipif_not_matplotlib
 def test_latex_to_html():
     img = latextools.latex_to_html("$x^2$")
     assert "data:image/png;base64,iVBOR" in img
 
 
 def test_genelatex_no_wrap():
     """
     Test genelatex with wrap=False.
     """
     def mock_kpsewhich(filename):
         assert False, ("kpsewhich should not be called "
                        "(called with {0})".format(filename))
 
     with patch_latextool(mock_kpsewhich):
         assert '\n'.join(latextools.genelatex("body text", False)) == r'''\documentclass{article}
 \usepackage{amsmath}
 \usepackage{amsthm}
 \usepackage{amssymb}
 \usepackage{bm}
 \pagestyle{empty}
 \begin{document}
 body text
 \end{document}'''
 
 
 def test_genelatex_wrap_with_breqn():
     """
     Test genelatex with wrap=True for the case breqn.sty is installed.
     """
     def mock_kpsewhich(filename):
         assert filename == "breqn.sty"
         return "path/to/breqn.sty"
 
     with patch_latextool(mock_kpsewhich):
         assert '\n'.join(latextools.genelatex("x^2", True)) == r'''\documentclass{article}
 \usepackage{amsmath}
 \usepackage{amsthm}
 \usepackage{amssymb}
 \usepackage{bm}
 \usepackage{breqn}
 \pagestyle{empty}
 \begin{document}
 \begin{dmath*}
 x^2
 \end{dmath*}
 \end{document}'''
 
 
 def test_genelatex_wrap_without_breqn():
     """
     Test genelatex with wrap=True for the case breqn.sty is not installed.
     """
     def mock_kpsewhich(filename):
         assert filename == "breqn.sty"
         return None
 
     with patch_latextool(mock_kpsewhich):
         assert '\n'.join(latextools.genelatex("x^2", True)) == r'''\documentclass{article}
 \usepackage{amsmath}
 \usepackage{amsthm}
 \usepackage{amssymb}
 \usepackage{bm}
 \pagestyle{empty}
 \begin{document}
 $$x^2$$
 \end{document}'''
 
 
 @skipif_not_matplotlib
 @onlyif_cmds_exist('latex', 'dvipng')
 def test_latex_to_png_color():
     """
     Test color settings for latex_to_png.
     """
     latex_string = "$x^2$"
     default_value = latextools.latex_to_png(latex_string, wrap=False)
     default_hexblack = latextools.latex_to_png(latex_string, wrap=False,
                                                color='#000000')
     dvipng_default = latextools.latex_to_png_dvipng(latex_string, False)
     dvipng_black = latextools.latex_to_png_dvipng(latex_string, False, 'Black')
     assert dvipng_default == dvipng_black
     mpl_default = latextools.latex_to_png_mpl(latex_string, False)
     mpl_black = latextools.latex_to_png_mpl(latex_string, False, 'Black')
     assert mpl_default == mpl_black
     assert default_value in [dvipng_black, mpl_black]
     assert default_hexblack in [dvipng_black, mpl_black]
 
     # Test that dvips name colors can be used without error
     dvipng_maroon = latextools.latex_to_png_dvipng(latex_string, False,
                                                    'Maroon')
     # And that it doesn't return the black one
     assert dvipng_black != dvipng_maroon
 
     mpl_maroon = latextools.latex_to_png_mpl(latex_string, False, 'Maroon')
     assert mpl_black != mpl_maroon
     mpl_white = latextools.latex_to_png_mpl(latex_string, False, 'White')
     mpl_hexwhite = latextools.latex_to_png_mpl(latex_string, False, '#FFFFFF')
     assert mpl_white == mpl_hexwhite
 
     mpl_white_scale = latextools.latex_to_png_mpl(latex_string, False,
                                                   'White', 1.2)
     assert mpl_white != mpl_white_scale
 
 
 def test_latex_to_png_invalid_hex_colors():
     """
     Test that invalid hex colors provided to dvipng gives an exception.
     """
     latex_string = "$x^2$"
     pytest.raises(
         ValueError,
         lambda: latextools.latex_to_png(
             latex_string, backend="dvipng", color="#f00bar"
         ),
     )
     pytest.raises(
         ValueError,
         lambda: latextools.latex_to_png(latex_string, backend="dvipng", color="#f00"),
     )

IPython/lib/tests/test_pretty.py

@@ -1,536 +1,536 b''
 # coding: utf-8
 """Tests for IPython.lib.pretty."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 from collections import Counter, defaultdict, deque, OrderedDict, UserList
 import os
 import pytest
 import types
 import string
 import sys
 import unittest
 
 import pytest
 
 from IPython.lib import pretty
 
 from io import StringIO
 
 
 class MyList(object):
     def __init__(self, content):
         self.content = content
     def _repr_pretty_(self, p, cycle):
         if cycle:
             p.text("MyList(...)")
         else:
             with p.group(3, "MyList(", ")"):
                 for (i, child) in enumerate(self.content):
                     if i:
                         p.text(",")
                         p.breakable()
                     else:
                         p.breakable("")
                     p.pretty(child)
 
 
 class MyDict(dict):
     def _repr_pretty_(self, p, cycle):
         p.text("MyDict(...)")
 
 class MyObj(object):
     def somemethod(self):
         pass
 
 
 class Dummy1(object):
     def _repr_pretty_(self, p, cycle):
         p.text("Dummy1(...)")
 
 class Dummy2(Dummy1):
     _repr_pretty_ = None
 
 class NoModule(object):
     pass
 
 NoModule.__module__ = None
 
 class Breaking(object):
     def _repr_pretty_(self, p, cycle):
         with p.group(4,"TG: ",":"):
             p.text("Breaking(")
             p.break_()
             p.text(")")
 
 class BreakingRepr(object):
     def __repr__(self):
         return "Breaking(\n)"
 
 class BadRepr(object):
     def __repr__(self):
         return 1/0
 
 
 def test_indentation():
     """Test correct indentation in groups"""
     count = 40
     gotoutput = pretty.pretty(MyList(range(count)))
     expectedoutput = "MyList(\n" + ",\n".join("   %d" % i for i in range(count)) + ")"
 
     assert gotoutput == expectedoutput
 
 
 def test_dispatch():
     """
     Test correct dispatching: The _repr_pretty_ method for MyDict
     must be found before the registered printer for dict.
     """
     gotoutput = pretty.pretty(MyDict())
     expectedoutput = "MyDict(...)"
 
     assert gotoutput == expectedoutput
 
 
 def test_callability_checking():
     """
     Test that the _repr_pretty_ method is tested for callability and skipped if
     not.
     """
     gotoutput = pretty.pretty(Dummy2())
     expectedoutput = "Dummy1(...)"
 
     assert gotoutput == expectedoutput
 
 
 @pytest.mark.parametrize(
     "obj,expected_output",
     zip(
         [
             set(),
             frozenset(),
             set([1]),
             frozenset([1]),
             set([1, 2]),
             frozenset([1, 2]),
             set([-1, -2, -3]),
         ],
         [
             "set()",
             "frozenset()",
             "{1}",
             "frozenset({1})",
             "{1, 2}",
             "frozenset({1, 2})",
             "{-3, -2, -1}",
         ],
     ),
 )
 def test_sets(obj, expected_output):
     """
     Test that set and frozenset use Python 3 formatting.
     """
     got_output = pretty.pretty(obj)
     assert got_output == expected_output
 
 
 def test_pprint_heap_allocated_type():
     """
     Test that pprint works for heap allocated types.
     """
     module_name = "xxlimited" if sys.version_info < (3, 10) else "xxlimited_35"
     xxlimited = pytest.importorskip(module_name)
     output = pretty.pretty(xxlimited.Null)
     assert output == "xxlimited.Null"
 
 
 def test_pprint_nomod():
     """
     Test that pprint works for classes with no __module__.
     """
     output = pretty.pretty(NoModule)
     assert output == "NoModule"
 
 
 def test_pprint_break():
     """
     Test that p.break_ produces expected output
     """
     output = pretty.pretty(Breaking())
     expected = "TG: Breaking(\n    ):"
     assert output == expected
 
 def test_pprint_break_repr():
     """
     Test that p.break_ is used in repr
     """
     output = pretty.pretty([[BreakingRepr()]])
     expected = "[[Breaking(\n  )]]"
     assert output == expected
 
     output = pretty.pretty([[BreakingRepr()]*2])
     expected = "[[Breaking(\n  ),\n  Breaking(\n  )]]"
     assert output == expected
 
 def test_bad_repr():
     """Don't catch bad repr errors"""
     with pytest.raises(ZeroDivisionError):
         pretty.pretty(BadRepr())
 
 class BadException(Exception):
     def __str__(self):
         return -1
 
 class ReallyBadRepr(object):
     __module__ = 1
     @property
     def __class__(self):
         raise ValueError("I am horrible")
 
     def __repr__(self):
         raise BadException()
 
 def test_really_bad_repr():
     with pytest.raises(BadException):
         pretty.pretty(ReallyBadRepr())
 
 
 class SA(object):
     pass
 
 class SB(SA):
     pass
 
 class TestsPretty(unittest.TestCase):
 
     def test_super_repr(self):
         # "<super: module_name.SA, None>"
         output = pretty.pretty(super(SA))
         self.assertRegex(output, r"<super: \S+.SA, None>")
 
         # "<super: module_name.SA, <module_name.SB at 0x...>>"
         sb = SB()
         output = pretty.pretty(super(SA, sb))
         self.assertRegex(output, r"<super: \S+.SA,\s+<\S+.SB at 0x\S+>>")
 
 
     def test_long_list(self):
         lis = list(range(10000))
         p = pretty.pretty(lis)
         last2 = p.rsplit('\n', 2)[-2:]
         self.assertEqual(last2, [' 999,', ' ...]'])
 
     def test_long_set(self):
         s = set(range(10000))
         p = pretty.pretty(s)
         last2 = p.rsplit('\n', 2)[-2:]
         self.assertEqual(last2, [' 999,', ' ...}'])
 
     def test_long_tuple(self):
         tup = tuple(range(10000))
         p = pretty.pretty(tup)
         last2 = p.rsplit('\n', 2)[-2:]
         self.assertEqual(last2, [' 999,', ' ...)'])
 
     def test_long_dict(self):
         d = { n:n for n in range(10000) }
         p = pretty.pretty(d)
         last2 = p.rsplit('\n', 2)[-2:]
         self.assertEqual(last2, [' 999: 999,', ' ...}'])
 
     def test_unbound_method(self):
         output = pretty.pretty(MyObj.somemethod)
         self.assertIn('MyObj.somemethod', output)
 
 
 class MetaClass(type):
     def __new__(cls, name):
         return type.__new__(cls, name, (object,), {'name': name})
 
     def __repr__(self):
         return "[CUSTOM REPR FOR CLASS %s]" % self.name
 
 
 ClassWithMeta = MetaClass('ClassWithMeta')
 
 
 def test_metaclass_repr():
     output = pretty.pretty(ClassWithMeta)
     assert output == "[CUSTOM REPR FOR CLASS ClassWithMeta]"
 
 
 def test_unicode_repr():
     u = u"üniçodé"
     ustr = u
 
     class C(object):
         def __repr__(self):
             return ustr
 
     c = C()
     p = pretty.pretty(c)
     assert p == u
     p = pretty.pretty([c])
-    assert p == u"[%s]" % u
+    assert p == "[%s]" % u
 
 
 def test_basic_class():
     def type_pprint_wrapper(obj, p, cycle):
         if obj is MyObj:
             type_pprint_wrapper.called = True
         return pretty._type_pprint(obj, p, cycle)
     type_pprint_wrapper.called = False
 
     stream = StringIO()
     printer = pretty.RepresentationPrinter(stream)
     printer.type_pprinters[type] = type_pprint_wrapper
     printer.pretty(MyObj)
     printer.flush()
     output = stream.getvalue()
 
     assert output == "%s.MyObj" % __name__
     assert type_pprint_wrapper.called is True
 
 
 def test_collections_userlist():
     # Create userlist with cycle
     a = UserList()
     a.append(a)
 
     cases = [
         (UserList(), "UserList([])"),
         (
             UserList(i for i in range(1000, 1020)),
             "UserList([1000,\n"
             "          1001,\n"
             "          1002,\n"
             "          1003,\n"
             "          1004,\n"
             "          1005,\n"
             "          1006,\n"
             "          1007,\n"
             "          1008,\n"
             "          1009,\n"
             "          1010,\n"
             "          1011,\n"
             "          1012,\n"
             "          1013,\n"
             "          1014,\n"
             "          1015,\n"
             "          1016,\n"
             "          1017,\n"
             "          1018,\n"
             "          1019])",
         ),
         (a, "UserList([UserList(...)])"),
     ]
     for obj, expected in cases:
         assert pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 def test_collections_defaultdict():
     # Create defaultdicts with cycles
     a = defaultdict()
     a.default_factory = a
     b = defaultdict(list)
     b['key'] = b
 
     # Dictionary order cannot be relied on, test against single keys.
     cases = [
         (defaultdict(list), 'defaultdict(list, {})'),
         (defaultdict(list, {'key': '-' * 50}),
          "defaultdict(list,\n"
          "            {'key': '--------------------------------------------------'})"),
         (a, 'defaultdict(defaultdict(...), {})'),
         (b, "defaultdict(list, {'key': defaultdict(...)})"),
     ]
     for obj, expected in cases:
         assert pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 def test_collections_ordereddict():
     # Create OrderedDict with cycle
     a = OrderedDict()
     a['key'] = a
 
     cases = [
         (OrderedDict(), 'OrderedDict()'),
         (OrderedDict((i, i) for i in range(1000, 1010)),
          'OrderedDict([(1000, 1000),\n'
          '             (1001, 1001),\n'
          '             (1002, 1002),\n'
          '             (1003, 1003),\n'
          '             (1004, 1004),\n'
          '             (1005, 1005),\n'
          '             (1006, 1006),\n'
          '             (1007, 1007),\n'
          '             (1008, 1008),\n'
          '             (1009, 1009)])'),
         (a, "OrderedDict([('key', OrderedDict(...))])"),
     ]
     for obj, expected in cases:
         assert pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 def test_collections_deque():
     # Create deque with cycle
     a = deque()
     a.append(a)
 
     cases = [
         (deque(), 'deque([])'),
         (deque(i for i in range(1000, 1020)),
          'deque([1000,\n'
          '       1001,\n'
          '       1002,\n'
          '       1003,\n'
          '       1004,\n'
          '       1005,\n'
          '       1006,\n'
          '       1007,\n'
          '       1008,\n'
          '       1009,\n'
          '       1010,\n'
          '       1011,\n'
          '       1012,\n'
          '       1013,\n'
          '       1014,\n'
          '       1015,\n'
          '       1016,\n'
          '       1017,\n'
          '       1018,\n'
          '       1019])'),
         (a, 'deque([deque(...)])'),
     ]
     for obj, expected in cases:
         assert pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 def test_collections_counter():
     class MyCounter(Counter):
         pass
     cases = [
         (Counter(), 'Counter()'),
         (Counter(a=1), "Counter({'a': 1})"),
         (MyCounter(a=1), "MyCounter({'a': 1})"),
     ]
     for obj, expected in cases:
         assert pretty.pretty(obj) == expected
 
 # TODO : pytest.mark.parametrise once nose is gone.
 def test_mappingproxy():
     MP = types.MappingProxyType
     underlying_dict = {}
     mp_recursive = MP(underlying_dict)
     underlying_dict[2] = mp_recursive
     underlying_dict[3] = underlying_dict
 
     cases = [
         (MP({}), "mappingproxy({})"),
         (MP({None: MP({})}), "mappingproxy({None: mappingproxy({})})"),
         (MP({k: k.upper() for k in string.ascii_lowercase}),
          "mappingproxy({'a': 'A',\n"
          "              'b': 'B',\n"
          "              'c': 'C',\n"
          "              'd': 'D',\n"
          "              'e': 'E',\n"
          "              'f': 'F',\n"
          "              'g': 'G',\n"
          "              'h': 'H',\n"
          "              'i': 'I',\n"
          "              'j': 'J',\n"
          "              'k': 'K',\n"
          "              'l': 'L',\n"
          "              'm': 'M',\n"
          "              'n': 'N',\n"
          "              'o': 'O',\n"
          "              'p': 'P',\n"
          "              'q': 'Q',\n"
          "              'r': 'R',\n"
          "              's': 'S',\n"
          "              't': 'T',\n"
          "              'u': 'U',\n"
          "              'v': 'V',\n"
          "              'w': 'W',\n"
          "              'x': 'X',\n"
          "              'y': 'Y',\n"
          "              'z': 'Z'})"),
         (mp_recursive, "mappingproxy({2: {...}, 3: {2: {...}, 3: {...}}})"),
         (underlying_dict,
          "{2: mappingproxy({2: {...}, 3: {...}}), 3: {...}}"),
     ]
     for obj, expected in cases:
         assert pretty.pretty(obj) == expected
 
 
 # TODO : pytest.mark.parametrise once nose is gone.
 def test_simplenamespace():
     SN = types.SimpleNamespace
 
     sn_recursive = SN()
     sn_recursive.first = sn_recursive
     sn_recursive.second = sn_recursive
     cases = [
         (SN(), "namespace()"),
         (SN(x=SN()), "namespace(x=namespace())"),
         (SN(a_long_name=[SN(s=string.ascii_lowercase)]*3, a_short_name=None),
          "namespace(a_long_name=[namespace(s='abcdefghijklmnopqrstuvwxyz'),\n"
          "                       namespace(s='abcdefghijklmnopqrstuvwxyz'),\n"
          "                       namespace(s='abcdefghijklmnopqrstuvwxyz')],\n"
          "          a_short_name=None)"),
         (sn_recursive, "namespace(first=namespace(...), second=namespace(...))"),
     ]
     for obj, expected in cases:
         assert pretty.pretty(obj) == expected
 
 
 def test_pretty_environ():
     dict_repr = pretty.pretty(dict(os.environ))
     # reindent to align with 'environ' prefix
     dict_indented = dict_repr.replace('\n', '\n' + (' ' * len('environ')))
     env_repr = pretty.pretty(os.environ)
     assert env_repr == "environ" + dict_indented
 
 
 def test_function_pretty():
     "Test pretty print of function"
     # posixpath is a pure python module, its interface is consistent
     # across Python distributions
     import posixpath
 
     assert pretty.pretty(posixpath.join) == "<function posixpath.join(a, *p)>"
 
     # custom function
     def meaning_of_life(question=None):
         if question:
             return 42
         return "Don't panic"
 
     assert "meaning_of_life(question=None)" in pretty.pretty(meaning_of_life)
 
 
 class OrderedCounter(Counter, OrderedDict):
     'Counter that remembers the order elements are first encountered'
 
     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))
 
     def __reduce__(self):
         return self.__class__, (OrderedDict(self),)
 
 class MySet(set):  # Override repr of a basic type
     def __repr__(self):
         return 'mine'
 
 def test_custom_repr():
     """A custom repr should override a pretty printer for a parent type"""
     oc = OrderedCounter("abracadabra")
     assert "OrderedCounter(OrderedDict" in pretty.pretty(oc)
 
     assert pretty.pretty(MySet()) == "mine"

IPython/testing/plugin/dtexample.py

@@ -1,167 +1,167 b''
 """Simple example using doctests.
 
 This file just contains doctests both using plain python and IPython prompts.
 All tests should be loaded by nose.
 """
 
 import os
 
 
 def pyfunc():
     """Some pure python tests...
 
     >>> pyfunc()
     'pyfunc'
 
     >>> import os
 
     >>> 2+3
     5
 
     >>> for i in range(3):
     ...     print(i, end=' ')
     ...     print(i+1, end=' ')
     ...
     0 1 1 2 2 3 
     """
     return 'pyfunc'
 
 def ipfunc():
     """Some ipython tests...
 
     In [1]: import os
 
     In [3]: 2+3
     Out[3]: 5
 
     In [26]: for i in range(3):
        ....:     print(i, end=' ')
        ....:     print(i+1, end=' ')
        ....:
     0 1 1 2 2 3 
 
 
     It's OK to use '_' for the last result, but do NOT try to use IPython's
     numbered history of _NN outputs, since those won't exist under the
     doctest environment:
 
     In [7]: 'hi'
     Out[7]: 'hi'
 
     In [8]: print(repr(_))
     'hi'
     
     In [7]: 3+4
     Out[7]: 7
 
     In [8]: _+3
     Out[8]: 10
 
     In [9]: ipfunc()
     Out[9]: 'ipfunc'
     """
-    return 'ipfunc'
+    return "ipfunc"
 
 
 def ipos():
     """Examples that access the operating system work:
 
     In [1]: !echo hello
     hello
 
     In [2]: !echo hello > /tmp/foo_iptest
 
     In [3]: !cat /tmp/foo_iptest
     hello
 
     In [4]: rm -f /tmp/foo_iptest
     """
     pass
 
 
 ipos.__skip_doctest__ = os.name == "nt"
 
 
 def ranfunc():
     """A function with some random output.
 
        Normal examples are verified as usual:
        >>> 1+3
        4
 
        But if you put '# random' in the output, it is ignored:
        >>> 1+3
        junk goes here...  # random
 
        >>> 1+2
        again,  anything goes #random
        if multiline, the random mark is only needed once.
 
        >>> 1+2
        You can also put the random marker at the end:
        # random
 
        >>> 1+2
        # random
        .. or at the beginning.
 
        More correct input is properly verified:
        >>> ranfunc()
        'ranfunc'
     """
     return 'ranfunc'
 
 
 def random_all():
     """A function where we ignore the output of ALL examples.
 
     Examples:
 
       # all-random
 
       This mark tells the testing machinery that all subsequent examples should
       be treated as random (ignoring their output).  They are still executed,
       so if a they raise an error, it will be detected as such, but their
       output is completely ignored.
 
       >>> 1+3
       junk goes here...
 
       >>> 1+3
       klasdfj;
 
       >>> 1+2
       again,  anything goes
       blah...
     """
     pass
 
 def iprand():
     """Some ipython tests with random output.
 
     In [7]: 3+4
     Out[7]: 7
 
     In [8]: print('hello')
     world  # random
 
     In [9]: iprand()
     Out[9]: 'iprand'
     """
     return 'iprand'
 
 def iprand_all():
     """Some ipython tests with fully random output.
 
     # all-random
     
     In [7]: 1
     Out[7]: 99
 
     In [8]: print('hello')
     world
 
     In [9]: iprand_all()
     Out[9]: 'junk'
     """
     return 'iprand_all'

IPython/utils/text.py

@@ -1,752 +1,752 b''
 # encoding: utf-8
 """
 Utilities for working with strings and text.
 
 Inheritance diagram:
 
 .. inheritance-diagram:: IPython.utils.text
    :parts: 3
 """
 
 import os
 import re
 import string
 import sys
 import textwrap
 from string import Formatter
 from pathlib import Path
 
 
 # datetime.strftime date format for ipython
 if sys.platform == 'win32':
     date_format = "%B %d, %Y"
 else:
     date_format = "%B %-d, %Y"
 
 class LSString(str):
     """String derivative with a special access attributes.
 
     These are normal strings, but with the special attributes:
 
         .l (or .list) : value as list (split on newlines).
         .n (or .nlstr): original value (the string itself).
         .s (or .spstr): value as whitespace-separated string.
         .p (or .paths): list of path objects (requires path.py package)
 
     Any values which require transformations are computed only once and
     cached.
 
     Such strings are very useful to efficiently interact with the shell, which
     typically only understands whitespace-separated options for commands."""
 
     def get_list(self):
         try:
             return self.__list
         except AttributeError:
             self.__list = self.split('\n')
             return self.__list
 
     l = list = property(get_list)
 
     def get_spstr(self):
         try:
             return self.__spstr
         except AttributeError:
             self.__spstr = self.replace('\n',' ')
             return self.__spstr
 
     s = spstr = property(get_spstr)
 
     def get_nlstr(self):
         return self
 
     n = nlstr = property(get_nlstr)
 
     def get_paths(self):
         try:
             return self.__paths
         except AttributeError:
             self.__paths = [Path(p) for p in self.split('\n') if os.path.exists(p)]
             return self.__paths
 
     p = paths = property(get_paths)
 
 # FIXME: We need to reimplement type specific displayhook and then add this
 # back as a custom printer. This should also be moved outside utils into the
 # core.
 
 # def print_lsstring(arg):
 #     """ Prettier (non-repr-like) and more informative printer for LSString """
 #     print "LSString (.p, .n, .l, .s available). Value:"
 #     print arg
 #
 #
 # print_lsstring = result_display.register(LSString)(print_lsstring)
 
 
 class SList(list):
     """List derivative with a special access attributes.
 
     These are normal lists, but with the special attributes:
 
     * .l (or .list) : value as list (the list itself).
     * .n (or .nlstr): value as a string, joined on newlines.
     * .s (or .spstr): value as a string, joined on spaces.
     * .p (or .paths): list of path objects (requires path.py package)
 
     Any values which require transformations are computed only once and
     cached."""
 
     def get_list(self):
         return self
 
     l = list = property(get_list)
 
     def get_spstr(self):
         try:
             return self.__spstr
         except AttributeError:
             self.__spstr = ' '.join(self)
             return self.__spstr
 
     s = spstr = property(get_spstr)
 
     def get_nlstr(self):
         try:
             return self.__nlstr
         except AttributeError:
             self.__nlstr = '\n'.join(self)
             return self.__nlstr
 
     n = nlstr = property(get_nlstr)
 
     def get_paths(self):
         try:
             return self.__paths
         except AttributeError:
             self.__paths = [Path(p) for p in self if os.path.exists(p)]
             return self.__paths
 
     p = paths = property(get_paths)
 
     def grep(self, pattern, prune = False, field = None):
         """ Return all strings matching 'pattern' (a regex or callable)
 
         This is case-insensitive. If prune is true, return all items
         NOT matching the pattern.
 
         If field is specified, the match must occur in the specified
         whitespace-separated field.
 
         Examples::
 
             a.grep( lambda x: x.startswith('C') )
             a.grep('Cha.*log', prune=1)
             a.grep('chm', field=-1)
         """
 
         def match_target(s):
             if field is None:
                 return s
             parts = s.split()
             try:
                 tgt = parts[field]
                 return tgt
             except IndexError:
                 return ""
 
         if isinstance(pattern, str):
             pred = lambda x : re.search(pattern, x, re.IGNORECASE)
         else:
             pred = pattern
         if not prune:
             return SList([el for el in self if pred(match_target(el))])
         else:
             return SList([el for el in self if not pred(match_target(el))])
 
     def fields(self, *fields):
         """ Collect whitespace-separated fields from string list
 
         Allows quick awk-like usage of string lists.
 
         Example data (in var a, created by 'a = !ls -l')::
 
             -rwxrwxrwx  1 ville None      18 Dec 14  2006 ChangeLog
             drwxrwxrwx+ 6 ville None       0 Oct 24 18:05 IPython
 
         * ``a.fields(0)`` is ``['-rwxrwxrwx', 'drwxrwxrwx+']``
         * ``a.fields(1,0)`` is ``['1 -rwxrwxrwx', '6 drwxrwxrwx+']``
           (note the joining by space).
         * ``a.fields(-1)`` is ``['ChangeLog', 'IPython']``
 
         IndexErrors are ignored.
 
         Without args, fields() just split()'s the strings.
         """
         if len(fields) == 0:
             return [el.split() for el in self]
 
         res = SList()
         for el in [f.split() for f in self]:
             lineparts = []
 
             for fd in fields:
                 try:
                     lineparts.append(el[fd])
                 except IndexError:
                     pass
             if lineparts:
                 res.append(" ".join(lineparts))
 
         return res
 
     def sort(self,field= None,  nums = False):
         """ sort by specified fields (see fields())
 
         Example::
 
             a.sort(1, nums = True)
 
         Sorts a by second field, in numerical order (so that 21 > 3)
 
         """
 
         #decorate, sort, undecorate
         if field is not None:
             dsu = [[SList([line]).fields(field),  line] for line in self]
         else:
             dsu = [[line,  line] for line in self]
         if nums:
             for i in range(len(dsu)):
                 numstr = "".join([ch for ch in dsu[i][0] if ch.isdigit()])
                 try:
                     n = int(numstr)
                 except ValueError:
                     n = 0
                 dsu[i][0] = n
 
 
         dsu.sort()
         return SList([t[1] for t in dsu])
 
 
 # FIXME: We need to reimplement type specific displayhook and then add this
 # back as a custom printer. This should also be moved outside utils into the
 # core.
 
 # def print_slist(arg):
 #     """ Prettier (non-repr-like) and more informative printer for SList """
 #     print "SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):"
 #     if hasattr(arg,  'hideonce') and arg.hideonce:
 #         arg.hideonce = False
 #         return
 #
 #     nlprint(arg)   # This was a nested list printer, now removed.
 #
 # print_slist = result_display.register(SList)(print_slist)
 
 
 def indent(instr,nspaces=4, ntabs=0, flatten=False):
     """Indent a string a given number of spaces or tabstops.
 
     indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
 
     Parameters
     ----------
     instr : basestring
         The string to be indented.
     nspaces : int (default: 4)
         The number of spaces to be indented.
     ntabs : int (default: 0)
         The number of tabs to be indented.
     flatten : bool (default: False)
         Whether to scrub existing indentation.  If True, all lines will be
         aligned to the same indentation.  If False, existing indentation will
         be strictly increased.
 
     Returns
     -------
     str|unicode : string indented by ntabs and nspaces.
 
     """
     if instr is None:
         return
     ind = '\t'*ntabs+' '*nspaces
     if flatten:
         pat = re.compile(r'^\s*', re.MULTILINE)
     else:
         pat = re.compile(r'^', re.MULTILINE)
     outstr = re.sub(pat, ind, instr)
     if outstr.endswith(os.linesep+ind):
         return outstr[:-len(ind)]
     else:
         return outstr
 
 
 def list_strings(arg):
     """Always return a list of strings, given a string or list of strings
     as input.
 
     Examples
     --------
     ::
 
         In [7]: list_strings('A single string')
         Out[7]: ['A single string']
 
         In [8]: list_strings(['A single string in a list'])
         Out[8]: ['A single string in a list']
 
         In [9]: list_strings(['A','list','of','strings'])
         Out[9]: ['A', 'list', 'of', 'strings']
     """
 
     if isinstance(arg, str):
         return [arg]
     else:
         return arg
 
 
 def marquee(txt='',width=78,mark='*'):
     """Return the input string centered in a 'marquee'.
 
     Examples
     --------
     ::
 
         In [16]: marquee('A test',40)
         Out[16]: '**************** A test ****************'
 
         In [17]: marquee('A test',40,'-')
         Out[17]: '---------------- A test ----------------'
 
         In [18]: marquee('A test',40,' ')
         Out[18]: '                 A test                 '
 
     """
     if not txt:
         return (mark*width)[:width]
     nmark = (width-len(txt)-2)//len(mark)//2
     if nmark < 0: nmark =0
     marks = mark*nmark
     return '%s %s %s' % (marks,txt,marks)
 
 
 ini_spaces_re = re.compile(r'^(\s+)')
 
 def num_ini_spaces(strng):
     """Return the number of initial spaces in a string"""
 
     ini_spaces = ini_spaces_re.match(strng)
     if ini_spaces:
         return ini_spaces.end()
     else:
         return 0
 
 
 def format_screen(strng):
     """Format a string for screen printing.
 
     This removes some latex-type format codes."""
     # Paragraph continue
     par_re = re.compile(r'\\$',re.MULTILINE)
     strng = par_re.sub('',strng)
     return strng
 
 
 def dedent(text):
     """Equivalent of textwrap.dedent that ignores unindented first line.
 
     This means it will still dedent strings like:
     '''foo
     is a bar
     '''
 
     For use in wrap_paragraphs.
     """
 
     if text.startswith('\n'):
         # text starts with blank line, don't ignore the first line
         return textwrap.dedent(text)
 
     # split first line
     splits = text.split('\n',1)
     if len(splits) == 1:
         # only one line
         return textwrap.dedent(text)
 
     first, rest = splits
     # dedent everything but the first line
     rest = textwrap.dedent(rest)
     return '\n'.join([first, rest])
 
 
 def wrap_paragraphs(text, ncols=80):
     """Wrap multiple paragraphs to fit a specified width.
 
     This is equivalent to textwrap.wrap, but with support for multiple
     paragraphs, as separated by empty lines.
 
     Returns
     -------
     list of complete paragraphs, wrapped to fill `ncols` columns.
     """
     paragraph_re = re.compile(r'\n(\s*\n)+', re.MULTILINE)
     text = dedent(text).strip()
     paragraphs = paragraph_re.split(text)[::2] # every other entry is space
     out_ps = []
     indent_re = re.compile(r'\n\s+', re.MULTILINE)
     for p in paragraphs:
         # presume indentation that survives dedent is meaningful formatting,
         # so don't fill unless text is flush.
         if indent_re.search(p) is None:
             # wrap paragraph
             p = textwrap.fill(p, ncols)
         out_ps.append(p)
     return out_ps
 
 
 def strip_email_quotes(text):
     """Strip leading email quotation characters ('>').
 
     Removes any combination of leading '>' interspersed with whitespace that
     appears *identically* in all lines of the input text.
 
     Parameters
     ----------
     text : str
 
     Examples
     --------
 
     Simple uses::
 
         In [2]: strip_email_quotes('> > text')
         Out[2]: 'text'
 
         In [3]: strip_email_quotes('> > text\\n> > more')
         Out[3]: 'text\\nmore'
 
     Note how only the common prefix that appears in all lines is stripped::
 
         In [4]: strip_email_quotes('> > text\\n> > more\\n> more...')
         Out[4]: '> text\\n> more\\nmore...'
 
     So if any line has no quote marks ('>'), then none are stripped from any
     of them ::
 
         In [5]: strip_email_quotes('> > text\\n> > more\\nlast different')
         Out[5]: '> > text\\n> > more\\nlast different'
     """
     lines = text.splitlines()
     strip_len = 0
 
     for characters in zip(*lines):
         # Check if all characters in this position are the same
         if len(set(characters)) > 1:
             break
         prefix_char = characters[0]
 
         if prefix_char in string.whitespace or prefix_char == ">":
             strip_len += 1
         else:
             break
 
     text = "\n".join([ln[strip_len:] for ln in lines])
     return text
 
 
 def strip_ansi(source):
     """
     Remove ansi escape codes from text.
 
     Parameters
     ----------
     source : str
         Source to remove the ansi from
     """
     return re.sub(r'\033\[(\d|;)+?m', '', source)
 
 
 class EvalFormatter(Formatter):
     """A String Formatter that allows evaluation of simple expressions.
     
     Note that this version interprets a `:`  as specifying a format string (as per
     standard string formatting), so if slicing is required, you must explicitly
     create a slice.
     
     This is to be used in templating cases, such as the parallel batch
     script templates, where simple arithmetic on arguments is useful.
 
     Examples
     --------
     ::
 
         In [1]: f = EvalFormatter()
         In [2]: f.format('{n//4}', n=8)
         Out[2]: '2'
 
         In [3]: f.format("{greeting[slice(2,4)]}", greeting="Hello")
         Out[3]: 'll'
     """
     def get_field(self, name, args, kwargs):
         v = eval(name, kwargs)
         return v, name
 
 #XXX: As of Python 3.4, the format string parsing no longer splits on a colon
 # inside [], so EvalFormatter can handle slicing. Once we only support 3.4 and
 # above, it should be possible to remove FullEvalFormatter.
 
 class FullEvalFormatter(Formatter):
     """A String Formatter that allows evaluation of simple expressions.
     
     Any time a format key is not found in the kwargs,
     it will be tried as an expression in the kwargs namespace.
     
     Note that this version allows slicing using [1:2], so you cannot specify
     a format string. Use :class:`EvalFormatter` to permit format strings.
     
     Examples
     --------
     ::
 
         In [1]: f = FullEvalFormatter()
         In [2]: f.format('{n//4}', n=8)
         Out[2]: '2'
 
         In [3]: f.format('{list(range(5))[2:4]}')
         Out[3]: '[2, 3]'
 
         In [4]: f.format('{3*2}')
         Out[4]: '6'
     """
     # copied from Formatter._vformat with minor changes to allow eval
     # and replace the format_spec code with slicing
     def vformat(self, format_string:str, args, kwargs)->str:
         result = []
         for literal_text, field_name, format_spec, conversion in \
                 self.parse(format_string):
 
             # output the literal text
             if literal_text:
                 result.append(literal_text)
 
             # if there's a field, output it
             if field_name is not None:
                 # this is some markup, find the object and do
                 # the formatting
 
                 if format_spec:
                     # override format spec, to allow slicing:
                     field_name = ':'.join([field_name, format_spec])
 
                 # eval the contents of the field for the object
                 # to be formatted
                 obj = eval(field_name, kwargs)
 
                 # do any conversion on the resulting object
                 obj = self.convert_field(obj, conversion)
 
                 # format the object and append to the result
                 result.append(self.format_field(obj, ''))
 
         return ''.join(result)
 
 
 class DollarFormatter(FullEvalFormatter):
     """Formatter allowing Itpl style $foo replacement, for names and attribute
     access only. Standard {foo} replacement also works, and allows full
     evaluation of its arguments.
 
     Examples
     --------
     ::
 
         In [1]: f = DollarFormatter()
         In [2]: f.format('{n//4}', n=8)
         Out[2]: '2'
 
         In [3]: f.format('23 * 76 is $result', result=23*76)
         Out[3]: '23 * 76 is 1748'
 
         In [4]: f.format('$a or {b}', a=1, b=2)
         Out[4]: '1 or 2'
     """
     _dollar_pattern_ignore_single_quote = re.compile(r"(.*?)\$(\$?[\w\.]+)(?=([^']*'[^']*')*[^']*$)")
     def parse(self, fmt_string):
         for literal_txt, field_name, format_spec, conversion \
                     in Formatter.parse(self, fmt_string):
             
             # Find $foo patterns in the literal text.
             continue_from = 0
             txt = ""
             for m in self._dollar_pattern_ignore_single_quote.finditer(literal_txt):
                 new_txt, new_field = m.group(1,2)
                 # $$foo --> $foo
                 if new_field.startswith("$"):
                     txt += new_txt + new_field
                 else:
                     yield (txt + new_txt, new_field, "", None)
                     txt = ""
                 continue_from = m.end()
             
             # Re-yield the {foo} style pattern
             yield (txt + literal_txt[continue_from:], field_name, format_spec, conversion)
 
     def __repr__(self):
         return "<DollarFormatter>"
 
 #-----------------------------------------------------------------------------
 # Utils to columnize a list of string
 #-----------------------------------------------------------------------------
 
 def _col_chunks(l, max_rows, row_first=False):
     """Yield successive max_rows-sized column chunks from l."""
     if row_first:
         ncols = (len(l) // max_rows) + (len(l) % max_rows > 0)
         for i in range(ncols):
             yield [l[j] for j in range(i, len(l), ncols)]
     else:
         for i in range(0, len(l), max_rows):
             yield l[i:(i + max_rows)]
 
 
 def _find_optimal(rlist, row_first=False, separator_size=2, displaywidth=80):
     """Calculate optimal info to columnize a list of string"""
     for max_rows in range(1, len(rlist) + 1):
         col_widths = list(map(max, _col_chunks(rlist, max_rows, row_first)))
         sumlength = sum(col_widths)
         ncols = len(col_widths)
         if sumlength + separator_size * (ncols - 1) <= displaywidth:
             break
     return {'num_columns': ncols,
             'optimal_separator_width': (displaywidth - sumlength) // (ncols - 1) if (ncols - 1) else 0,
             'max_rows': max_rows,
             'column_widths': col_widths
             }
 
 
 def _get_or_default(mylist, i, default=None):
     """return list item number, or default if don't exist"""
     if i >= len(mylist):
         return default
     else :
         return mylist[i]
 
 
 def compute_item_matrix(items, row_first=False, empty=None, *args, **kwargs) :
     """Returns a nested list, and info to columnize items
 
     Parameters
     ----------
     items
         list of strings to columize
     row_first : (default False)
         Whether to compute columns for a row-first matrix instead of
         column-first (default).
     empty : (default None)
         default value to fill list if needed
     separator_size : int (default=2)
         How much characters will be used as a separation between each columns.
     displaywidth : int (default=80)
         The width of the area onto which the columns should enter
 
     Returns
     -------
     strings_matrix
         nested list of string, the outer most list contains as many list as
         rows, the innermost lists have each as many element as columns. If the
         total number of elements in `items` does not equal the product of
         rows*columns, the last element of some lists are filled with `None`.
     dict_info
         some info to make columnize easier:
 
         num_columns
           number of columns
         max_rows
           maximum number of rows (final number may be less)
         column_widths
           list of with of each columns
         optimal_separator_width
           best separator width between columns
 
     Examples
     --------
     ::
 
         In [1]: l = ['aaa','b','cc','d','eeeee','f','g','h','i','j','k','l']
         In [2]: list, info = compute_item_matrix(l, displaywidth=12)
         In [3]: list
         Out[3]: [['aaa', 'f', 'k'], ['b', 'g', 'l'], ['cc', 'h', None], ['d', 'i', None], ['eeeee', 'j', None]]
         In [4]: ideal = {'num_columns': 3, 'column_widths': [5, 1, 1], 'optimal_separator_width': 2, 'max_rows': 5}
         In [5]: all((info[k] == ideal[k] for k in ideal.keys()))
         Out[5]: True
     """
     info = _find_optimal(list(map(len, items)), row_first, *args, **kwargs)
     nrow, ncol = info['max_rows'], info['num_columns']
     if row_first:
         return ([[_get_or_default(items, r * ncol + c, default=empty) for c in range(ncol)] for r in range(nrow)], info)
     else:
         return ([[_get_or_default(items, c * nrow + r, default=empty) for c in range(ncol)] for r in range(nrow)], info)
 
 
-def columnize(items, row_first=False, separator='  ', displaywidth=80, spread=False):
+def columnize(items, row_first=False, separator="  ", displaywidth=80, spread=False):
     """ Transform a list of strings into a single string with columns.
 
     Parameters
     ----------
     items : sequence of strings
         The strings to process.
     row_first : (default False)
         Whether to compute columns for a row-first matrix instead of
         column-first (default).
     separator : str, optional [default is two spaces]
         The string that separates columns.
     displaywidth : int, optional [default is 80]
         Width of the display in number of characters.
 
     Returns
     -------
     The formatted string.
     """
     if not items:
         return '\n'
     matrix, info = compute_item_matrix(items, row_first=row_first, separator_size=len(separator), displaywidth=displaywidth)
     if spread:
         separator = separator.ljust(int(info['optimal_separator_width']))
     fmatrix = [filter(None, x) for x in matrix]
     sjoin = lambda x : separator.join([ y.ljust(w, ' ') for y, w in zip(x, info['column_widths'])])
     return '\n'.join(map(sjoin, fmatrix))+'\n'
 
 
 def get_text_list(list_, last_sep=' and ', sep=", ", wrap_item_with=""):
     """
     Return a string with a natural enumeration of items
 
     >>> get_text_list(['a', 'b', 'c', 'd'])
     'a, b, c and d'
     >>> get_text_list(['a', 'b', 'c'], ' or ')
     'a, b or c'
     >>> get_text_list(['a', 'b', 'c'], ', ')
     'a, b, c'
     >>> get_text_list(['a', 'b'], ' or ')
     'a or b'
     >>> get_text_list(['a'])
     'a'
     >>> get_text_list([])
     ''
     >>> get_text_list(['a', 'b'], wrap_item_with="`")
     '`a` and `b`'
     >>> get_text_list(['a', 'b', 'c', 'd'], " = ", sep=" + ")
     'a + b + c = d'
     """
     if len(list_) == 0:
         return ''
     if wrap_item_with:
         list_ = ['%s%s%s' % (wrap_item_with, item, wrap_item_with) for
                  item in list_]
     if len(list_) == 1:
         return list_[0]
     return '%s%s%s' % (
         sep.join(i for i in list_[:-1]),
         last_sep, list_[-1])

docs/source/config/integrating.rst

@@ -1,173 +1,173 b''
 .. _integrating:
 
 =====================================
 Integrating your objects with IPython
 =====================================
 
 Tab completion
 ==============
 
 To change the attributes displayed by tab-completing your object, define a
 ``__dir__(self)`` method for it. For more details, see the documentation of the
 built-in `dir() function <http://docs.python.org/library/functions.html#dir>`_.
 
 You can also customise key completions for your objects, e.g. pressing tab after
 ``obj["a``. To do so, define a method ``_ipython_key_completions_()``, which
 returns a list of objects which are possible keys in a subscript expression
 ``obj[key]``.
 
 .. versionadded:: 5.0
    Custom key completions
 
 .. _integrating_rich_display:
 
 Rich display
 ============
 
 Custom methods
 ----------------------
 IPython can display richer representations of objects.
 To do this, you can define ``_ipython_display_()``, or any of a number of 
 ``_repr_*_()`` methods. 
 Note that these are surrounded by single, not double underscores.
 
 .. list-table:: Supported ``_repr_*_`` methods
    :widths: 20 15 15 15
    :header-rows: 1
    
    * - Format
      - REPL
      - Notebook
      - Qt Console
    * - ``_repr_pretty_``
      - yes
      - yes
      - yes
    * - ``_repr_svg_``
      - no
      - yes
      - yes
    * - ``_repr_png_``
      - no
      - yes
      - yes
    * - ``_repr_jpeg_``
      - no
      - yes
      - yes
    * - ``_repr_html_``
      - no
      - yes
      - no
    * - ``_repr_javascript_``
      - no
      - yes
      - no
    * - ``_repr_markdown_``
      - no
      - yes
      - no
    * - ``_repr_latex_``
      - no
      - yes
      - no
    * - ``_repr_mimebundle_``
      - no
      - ?
      - ?
 
 If the methods don't exist, or return ``None``, the standard ``repr()`` is used.
 
 For example::
 
     class Shout(object):
         def __init__(self, text):
             self.text = text
         
         def _repr_html_(self):
             return "<h1>" + self.text + "</h1>"
 
 
 Special methods
 ^^^^^^^^^^^^^^^
 
 Pretty printing
 """""""""""""""
 
 To customize how your object is pretty-printed, add a ``_repr_pretty_`` method
 to the class. 
 The method should accept a pretty printer, and a boolean that indicates whether
 the printer detected a cycle.
 The method should act on the printer to produce your customized pretty output.
 Here is an example::
 
     class MyObject(object):
 
         def _repr_pretty_(self, p, cycle):
             if cycle:
                 p.text('MyObject(...)')
             else:
                 p.text('MyObject[...]')
 
 For details on how to use the pretty printer, see :py:mod:`IPython.lib.pretty`.
 
 More powerful methods
 """""""""""""""""""""
 
 .. class:: MyObject
 
    .. method:: _repr_mimebundle_(include=None, exclude=None)
 
      Should return a dictionary of multiple formats, keyed by mimetype, or a tuple
      of two dictionaries: *data, metadata* (see :ref:`Metadata`).
      If this returns something, other ``_repr_*_`` methods are ignored.
      The method should take keyword arguments ``include`` and ``exclude``, though 
      it is not required to respect them.
 
    .. method:: _ipython_display_()
 
       Displays the object as a side effect; the return value is ignored. If this
       is defined, all other display methods are ignored.
       This method is ignored in the REPL.
 
 
 Metadata
 ^^^^^^^^
 
 We often want to provide frontends with guidance on how to display the data. To
-support this, ``_repr_*_()`` methods (except `_repr_pretty_``?) can also return a ``(data, metadata)``
+support this, ``_repr_*_()`` methods (except ``_repr_pretty_``?) can also return a ``(data, metadata)``
 tuple where ``metadata`` is a dictionary containing arbitrary key-value pairs for
 the frontend to interpret. An example use case is ``_repr_jpeg_()``, which can
 be set to return a jpeg image and a ``{'height': 400, 'width': 600}`` dictionary
 to inform the frontend how to size the image.
 
 
 
 Formatters for third-party types
 --------------------------------
 
 The user can also register formatters for types without modifying the class::
 
     from bar.baz import Foo
 
     def foo_html(obj):
         return '<marquee>Foo object %s</marquee>' % obj.name
 
     html_formatter = get_ipython().display_formatter.formatters['text/html']
     html_formatter.for_type(Foo, foo_html)
 
     # Or register a type without importing it - this does the same as above:
     html_formatter.for_type_by_name('bar.baz', 'Foo', foo_html)
 
 Custom exception tracebacks
 ===========================
 
 Rarely, you might want to display a custom traceback when reporting an
 exception. To do this, define the custom traceback using
 `_render_traceback_(self)` method which returns a list of strings, one string
 for each line of the traceback. For example, the `ipyparallel
 <https://ipyparallel.readthedocs.io/>`__ a parallel computing framework for
 IPython, does this to display errors from multiple engines.
 
 Please be conservative in using this feature; by replacing the default traceback
 you may hide important information from the user.

docs/source/whatsnew/github-stats-0.11.rst

@@ -1,528 +1,528 b''
 .. _issues_list_011:
 
 Issues closed in the 0.11 development cycle
 ===========================================
 
 In this cycle, we closed a total of 511 issues, 226 pull requests and 285
 regular issues; this is the full list (generated with the script
 `tools/github_stats.py`). We should note that a few of these were made on the
 0.10.x series, but we have no automatic way of filtering the issues by branch,
 so this reflects all of our development over the last two years, including work
 already released in 0.10.2:
 
 Pull requests (226):
 
 * `620 <https://github.com/ipython/ipython/issues/620>`_: Release notes and updates to GUI support docs for 0.11
 * `642 <https://github.com/ipython/ipython/issues/642>`_: fix typo in docs/examples/vim/README.rst
 * `631 <https://github.com/ipython/ipython/issues/631>`_: two-way vim-ipython integration
 * `637 <https://github.com/ipython/ipython/issues/637>`_: print is a function, this allows to properly exit ipython
 * `635 <https://github.com/ipython/ipython/issues/635>`_: support html representations in the notebook frontend
 * `639 <https://github.com/ipython/ipython/issues/639>`_: Updating the credits file
 * `628 <https://github.com/ipython/ipython/issues/628>`_: import pexpect from IPython.external in irunner
 * `596 <https://github.com/ipython/ipython/issues/596>`_: Irunner
 * `598 <https://github.com/ipython/ipython/issues/598>`_: Fix templates for CrashHandler
 * `590 <https://github.com/ipython/ipython/issues/590>`_: Desktop
 * `600 <https://github.com/ipython/ipython/issues/600>`_: Fix bug with non-ascii reprs inside pretty-printed lists.
 * `618 <https://github.com/ipython/ipython/issues/618>`_: I617
 * `599 <https://github.com/ipython/ipython/issues/599>`_: Gui Qt example and docs
 * `619 <https://github.com/ipython/ipython/issues/619>`_: manpage update
 * `582 <https://github.com/ipython/ipython/issues/582>`_: Updating sympy profile to match the exec_lines of isympy.
 * `578 <https://github.com/ipython/ipython/issues/578>`_: Check to see if correct source for decorated functions can be displayed
 * `589 <https://github.com/ipython/ipython/issues/589>`_: issue 588
 * `591 <https://github.com/ipython/ipython/issues/591>`_: simulate shell expansion on %run arguments, at least tilde expansion
 * `576 <https://github.com/ipython/ipython/issues/576>`_: Show message about %paste magic on an IndentationError
 * `574 <https://github.com/ipython/ipython/issues/574>`_: Getcwdu
 * `565 <https://github.com/ipython/ipython/issues/565>`_: don't move old config files, keep nagging the user
 * `575 <https://github.com/ipython/ipython/issues/575>`_: Added more docstrings to IPython.zmq.session.
 * `567 <https://github.com/ipython/ipython/issues/567>`_: fix trailing whitespace from resetting indentation
 * `564 <https://github.com/ipython/ipython/issues/564>`_: Command line args in docs
 * `560 <https://github.com/ipython/ipython/issues/560>`_: reorder qt support in kernel
 * `561 <https://github.com/ipython/ipython/issues/561>`_: command-line suggestions
 * `556 <https://github.com/ipython/ipython/issues/556>`_: qt_for_kernel: use matplotlib rcParams to decide between PyQt4 and PySide
 * `557 <https://github.com/ipython/ipython/issues/557>`_: Update usage.py to newapp
 * `555 <https://github.com/ipython/ipython/issues/555>`_: Rm default old config
 * `552 <https://github.com/ipython/ipython/issues/552>`_: update parallel code for py3k
 * `504 <https://github.com/ipython/ipython/issues/504>`_: Updating string formatting
 * `551 <https://github.com/ipython/ipython/issues/551>`_: Make pylab import all configurable
 * `496 <https://github.com/ipython/ipython/issues/496>`_: Qt editing keybindings
 * `550 <https://github.com/ipython/ipython/issues/550>`_: Support v2 PyQt4 APIs and PySide in kernel's GUI support
 * `546 <https://github.com/ipython/ipython/issues/546>`_: doc update
 * `548 <https://github.com/ipython/ipython/issues/548>`_: Fix sympy profile to work with sympy 0.7.
 * `542 <https://github.com/ipython/ipython/issues/542>`_: issue 440
 * `533 <https://github.com/ipython/ipython/issues/533>`_: Remove unused configobj and validate libraries from externals.
 * `538 <https://github.com/ipython/ipython/issues/538>`_: fix various tests on Windows
-* `540 <https://github.com/ipython/ipython/issues/540>`_: support `-pylab` flag with deprecation warning
+* `540 <https://github.com/ipython/ipython/issues/540>`_: support ``-pylab`` flag with deprecation warning
 * `537 <https://github.com/ipython/ipython/issues/537>`_: Docs update
-* `536 <https://github.com/ipython/ipython/issues/536>`_: `setup.py install` depends on setuptools on Windows
+* `536 <https://github.com/ipython/ipython/issues/536>`_: ``setup.py install`` depends on setuptools on Windows
 * `480 <https://github.com/ipython/ipython/issues/480>`_: Get help mid-command
 * `462 <https://github.com/ipython/ipython/issues/462>`_: Str and Bytes traitlets
 * `534 <https://github.com/ipython/ipython/issues/534>`_: Handle unicode properly in IPython.zmq.iostream
 * `527 <https://github.com/ipython/ipython/issues/527>`_: ZMQ displayhook
 * `526 <https://github.com/ipython/ipython/issues/526>`_: Handle asynchronous output in Qt console
 * `528 <https://github.com/ipython/ipython/issues/528>`_: Do not import deprecated functions from external decorators library.
 * `454 <https://github.com/ipython/ipython/issues/454>`_: New BaseIPythonApplication
 * `532 <https://github.com/ipython/ipython/issues/532>`_: Zmq unicode
 * `531 <https://github.com/ipython/ipython/issues/531>`_: Fix Parallel test
 * `525 <https://github.com/ipython/ipython/issues/525>`_: fallback on lsof if otool not found in libedit detection
 * `517 <https://github.com/ipython/ipython/issues/517>`_: Merge IPython.parallel.streamsession into IPython.zmq.session
 * `521 <https://github.com/ipython/ipython/issues/521>`_: use dict.get(key) instead of dict[key] for safety from KeyErrors
 * `492 <https://github.com/ipython/ipython/issues/492>`_: add QtConsoleApp using newapplication
 * `485 <https://github.com/ipython/ipython/issues/485>`_: terminal IPython with newapp
 * `486 <https://github.com/ipython/ipython/issues/486>`_: Use newapp in parallel code
 * `511 <https://github.com/ipython/ipython/issues/511>`_: Add a new line before displaying multiline strings in the Qt console.
 * `509 <https://github.com/ipython/ipython/issues/509>`_: i508
 * `501 <https://github.com/ipython/ipython/issues/501>`_: ignore EINTR in channel loops
 * `495 <https://github.com/ipython/ipython/issues/495>`_: Better selection of Qt bindings when QT_API is not specified
 * `498 <https://github.com/ipython/ipython/issues/498>`_: Check for .pyd as extension for binary files.
 * `494 <https://github.com/ipython/ipython/issues/494>`_: QtConsole zoom adjustments
 * `490 <https://github.com/ipython/ipython/issues/490>`_: fix UnicodeEncodeError writing SVG string to .svg file, fixes #489
 * `491 <https://github.com/ipython/ipython/issues/491>`_: add QtConsoleApp using newapplication
 * `479 <https://github.com/ipython/ipython/issues/479>`_: embed() doesn't load default config
 * `483 <https://github.com/ipython/ipython/issues/483>`_: Links launchpad -> github
 * `419 <https://github.com/ipython/ipython/issues/419>`_: %xdel magic
 * `477 <https://github.com/ipython/ipython/issues/477>`_: Add \n to lines in the log
 * `459 <https://github.com/ipython/ipython/issues/459>`_: use os.system for shell.system in Terminal frontend
 * `475 <https://github.com/ipython/ipython/issues/475>`_: i473
 * `471 <https://github.com/ipython/ipython/issues/471>`_: Add test decorator onlyif_unicode_paths.
 * `474 <https://github.com/ipython/ipython/issues/474>`_: Fix support for raw GTK and WX matplotlib backends.
 * `472 <https://github.com/ipython/ipython/issues/472>`_: Kernel event loop is robust against random SIGINT.
 * `460 <https://github.com/ipython/ipython/issues/460>`_: Share code for magic_edit
 * `469 <https://github.com/ipython/ipython/issues/469>`_: Add exit code when running all tests with iptest.
 * `464 <https://github.com/ipython/ipython/issues/464>`_: Add home directory expansion to IPYTHON_DIR environment variables.
 * `455 <https://github.com/ipython/ipython/issues/455>`_: Bugfix with logger
 * `448 <https://github.com/ipython/ipython/issues/448>`_: Separate out skip_doctest decorator
 * `453 <https://github.com/ipython/ipython/issues/453>`_: Draft of new main BaseIPythonApplication.
 * `452 <https://github.com/ipython/ipython/issues/452>`_: Use list/tuple/dict/set subclass's overridden __repr__ instead of the pretty
 * `398 <https://github.com/ipython/ipython/issues/398>`_: allow toggle of svg/png inline figure format
 * `381 <https://github.com/ipython/ipython/issues/381>`_: Support inline PNGs of matplotlib plots
 * `413 <https://github.com/ipython/ipython/issues/413>`_: Retries and Resubmit (#411 and #412)
 * `370 <https://github.com/ipython/ipython/issues/370>`_: Fixes to the display system
 * `449 <https://github.com/ipython/ipython/issues/449>`_: Fix issue 447 - inspecting old-style classes.
 * `423 <https://github.com/ipython/ipython/issues/423>`_: Allow type checking on elements of List,Tuple,Set traits
 * `400 <https://github.com/ipython/ipython/issues/400>`_: Config5
 * `421 <https://github.com/ipython/ipython/issues/421>`_: Generalise mechanism to put text at the next prompt in the Qt console.
 * `443 <https://github.com/ipython/ipython/issues/443>`_: pinfo code duplication
 * `429 <https://github.com/ipython/ipython/issues/429>`_: add check_pid, and handle stale PID info in ipcluster.
 * `431 <https://github.com/ipython/ipython/issues/431>`_: Fix error message in test_irunner
 * `427 <https://github.com/ipython/ipython/issues/427>`_: handle different SyntaxError messages in test_irunner
 * `424 <https://github.com/ipython/ipython/issues/424>`_: Irunner test failure
 * `430 <https://github.com/ipython/ipython/issues/430>`_: Small parallel doc typo
 * `422 <https://github.com/ipython/ipython/issues/422>`_: Make ipython-qtconsole a GUI script
 * `420 <https://github.com/ipython/ipython/issues/420>`_: Permit kernel std* to be redirected
 * `408 <https://github.com/ipython/ipython/issues/408>`_: History request
 * `388 <https://github.com/ipython/ipython/issues/388>`_: Add Emacs-style kill ring to Qt console
 * `414 <https://github.com/ipython/ipython/issues/414>`_: Warn on old config files
 * `415 <https://github.com/ipython/ipython/issues/415>`_: Prevent prefilter from crashing IPython
 * `418 <https://github.com/ipython/ipython/issues/418>`_: Minor configuration doc fixes
 * `407 <https://github.com/ipython/ipython/issues/407>`_: Update What's new documentation
 * `410 <https://github.com/ipython/ipython/issues/410>`_: Install notebook frontend
 * `406 <https://github.com/ipython/ipython/issues/406>`_: install IPython.zmq.gui
 * `393 <https://github.com/ipython/ipython/issues/393>`_: ipdir unicode
 * `397 <https://github.com/ipython/ipython/issues/397>`_: utils.io.Term.cin/out/err -> utils.io.stdin/out/err
 * `389 <https://github.com/ipython/ipython/issues/389>`_: DB fixes and Scheduler HWM
 * `374 <https://github.com/ipython/ipython/issues/374>`_: Various Windows-related fixes to IPython.parallel
 * `362 <https://github.com/ipython/ipython/issues/362>`_: fallback on defaultencoding if filesystemencoding is None
 * `382 <https://github.com/ipython/ipython/issues/382>`_: Shell's reset method clears namespace from last %run command.
 * `385 <https://github.com/ipython/ipython/issues/385>`_: Update iptest exclusions (fix #375)
 * `383 <https://github.com/ipython/ipython/issues/383>`_: Catch errors in querying readline which occur with pyreadline.
 * `373 <https://github.com/ipython/ipython/issues/373>`_: Remove runlines etc.
 * `364 <https://github.com/ipython/ipython/issues/364>`_: Single output
 * `372 <https://github.com/ipython/ipython/issues/372>`_: Multiline input push
 * `363 <https://github.com/ipython/ipython/issues/363>`_: Issue 125
 * `361 <https://github.com/ipython/ipython/issues/361>`_: don't rely on setuptools for readline dependency check
 * `349 <https://github.com/ipython/ipython/issues/349>`_: Fix %autopx magic
 * `355 <https://github.com/ipython/ipython/issues/355>`_: History save thread
 * `356 <https://github.com/ipython/ipython/issues/356>`_: Usability improvements to history in Qt console
 * `357 <https://github.com/ipython/ipython/issues/357>`_: Exit autocall
 * `353 <https://github.com/ipython/ipython/issues/353>`_: Rewrite quit()/exit()/Quit()/Exit() calls as magic
 * `354 <https://github.com/ipython/ipython/issues/354>`_: Cell tweaks
 * `345 <https://github.com/ipython/ipython/issues/345>`_: Attempt to address (partly) issue ipython/#342 by rewriting quit(), exit(), etc.
 * `352 <https://github.com/ipython/ipython/issues/352>`_: #342: Try to recover as intelligently as possible if user calls magic().
 * `346 <https://github.com/ipython/ipython/issues/346>`_: Dedent prefix bugfix + tests: #142
 * `348 <https://github.com/ipython/ipython/issues/348>`_: %reset doesn't reset prompt number.
 * `347 <https://github.com/ipython/ipython/issues/347>`_: Make ip.reset() work the same in interactive or non-interactive code.
 * `343 <https://github.com/ipython/ipython/issues/343>`_: make readline a dependency on OSX
 * `344 <https://github.com/ipython/ipython/issues/344>`_: restore auto debug behavior
 * `339 <https://github.com/ipython/ipython/issues/339>`_: fix for issue 337: incorrect/phantom tooltips for magics
 * `254 <https://github.com/ipython/ipython/issues/254>`_: newparallel branch (add zmq.parallel submodule)
 * `334 <https://github.com/ipython/ipython/issues/334>`_: Hard reset
 * `316 <https://github.com/ipython/ipython/issues/316>`_: Unicode win process
 * `332 <https://github.com/ipython/ipython/issues/332>`_: AST splitter
 * `325 <https://github.com/ipython/ipython/issues/325>`_: Removetwisted
 * `330 <https://github.com/ipython/ipython/issues/330>`_: Magic pastebin
 * `309 <https://github.com/ipython/ipython/issues/309>`_: Bug tests for GH Issues 238, 284, 306, 307. Skip module machinery if not installed. Known failures reported as 'K'
 * `331 <https://github.com/ipython/ipython/issues/331>`_: Tweak config loader for PyPy compatibility.
 * `319 <https://github.com/ipython/ipython/issues/319>`_: Rewrite code to restore readline history after an action
 * `329 <https://github.com/ipython/ipython/issues/329>`_: Do not store file contents in history when running a .ipy file.
 * `179 <https://github.com/ipython/ipython/issues/179>`_: Html notebook
 * `323 <https://github.com/ipython/ipython/issues/323>`_: Add missing external.pexpect to packages
 * `295 <https://github.com/ipython/ipython/issues/295>`_: Magic local scope
 * `315 <https://github.com/ipython/ipython/issues/315>`_: Unicode magic args
 * `310 <https://github.com/ipython/ipython/issues/310>`_: allow Unicode Command-Line options
 * `313 <https://github.com/ipython/ipython/issues/313>`_: Readline shortcuts
 * `311 <https://github.com/ipython/ipython/issues/311>`_: Qtconsole exit
 * `312 <https://github.com/ipython/ipython/issues/312>`_: History memory
 * `294 <https://github.com/ipython/ipython/issues/294>`_: Issue 290
 * `292 <https://github.com/ipython/ipython/issues/292>`_: Issue 31
 * `252 <https://github.com/ipython/ipython/issues/252>`_: Unicode issues
 * `235 <https://github.com/ipython/ipython/issues/235>`_: Fix history magic command's bugs wrt to full history and add -O option to display full history
 * `236 <https://github.com/ipython/ipython/issues/236>`_: History minus p flag
 * `261 <https://github.com/ipython/ipython/issues/261>`_: Adapt magic commands to new history system.
 * `282 <https://github.com/ipython/ipython/issues/282>`_: SQLite history
 * `191 <https://github.com/ipython/ipython/issues/191>`_: Unbundle external libraries
 * `199 <https://github.com/ipython/ipython/issues/199>`_: Magic arguments
 * `204 <https://github.com/ipython/ipython/issues/204>`_: Emacs completion bugfix
 * `293 <https://github.com/ipython/ipython/issues/293>`_: Issue 133
 * `249 <https://github.com/ipython/ipython/issues/249>`_: Writing unicode characters to a log file. (IPython 0.10.2.git)
 * `283 <https://github.com/ipython/ipython/issues/283>`_: Support for 256-color escape sequences in Qt console
 * `281 <https://github.com/ipython/ipython/issues/281>`_: Refactored and improved Qt console's HTML export facility
 * `237 <https://github.com/ipython/ipython/issues/237>`_: Fix185 (take two)
 * `251 <https://github.com/ipython/ipython/issues/251>`_: Issue 129
 * `278 <https://github.com/ipython/ipython/issues/278>`_: add basic XDG_CONFIG_HOME support
 * `275 <https://github.com/ipython/ipython/issues/275>`_: inline pylab cuts off labels on log plots
 * `280 <https://github.com/ipython/ipython/issues/280>`_: Add %precision magic
 * `259 <https://github.com/ipython/ipython/issues/259>`_: Pyside support
 * `193 <https://github.com/ipython/ipython/issues/193>`_: Make ipython cProfile-able
 * `272 <https://github.com/ipython/ipython/issues/272>`_: Magic examples
 * `219 <https://github.com/ipython/ipython/issues/219>`_: Doc magic pycat
 * `221 <https://github.com/ipython/ipython/issues/221>`_: Doc magic alias
 * `230 <https://github.com/ipython/ipython/issues/230>`_: Doc magic edit
 * `224 <https://github.com/ipython/ipython/issues/224>`_: Doc magic cpaste
 * `229 <https://github.com/ipython/ipython/issues/229>`_: Doc magic pdef
 * `273 <https://github.com/ipython/ipython/issues/273>`_: Docs build
 * `228 <https://github.com/ipython/ipython/issues/228>`_: Doc magic who
 * `233 <https://github.com/ipython/ipython/issues/233>`_: Doc magic cd
 * `226 <https://github.com/ipython/ipython/issues/226>`_: Doc magic pwd
 * `218 <https://github.com/ipython/ipython/issues/218>`_: Doc magic history
 * `231 <https://github.com/ipython/ipython/issues/231>`_: Doc magic reset
 * `225 <https://github.com/ipython/ipython/issues/225>`_: Doc magic save
 * `222 <https://github.com/ipython/ipython/issues/222>`_: Doc magic timeit
 * `223 <https://github.com/ipython/ipython/issues/223>`_: Doc magic colors
 * `203 <https://github.com/ipython/ipython/issues/203>`_: Small typos in zmq/blockingkernelmanager.py
 * `227 <https://github.com/ipython/ipython/issues/227>`_: Doc magic logon
 * `232 <https://github.com/ipython/ipython/issues/232>`_: Doc magic profile
 * `264 <https://github.com/ipython/ipython/issues/264>`_: Kernel logging
 * `220 <https://github.com/ipython/ipython/issues/220>`_: Doc magic edit
 * `268 <https://github.com/ipython/ipython/issues/268>`_: PyZMQ >= 2.0.10
 * `267 <https://github.com/ipython/ipython/issues/267>`_: GitHub Pages (again)
 * `266 <https://github.com/ipython/ipython/issues/266>`_: OSX-specific fixes to the Qt console
 * `255 <https://github.com/ipython/ipython/issues/255>`_: Gitwash typo
 * `265 <https://github.com/ipython/ipython/issues/265>`_: Fix string input2
 * `260 <https://github.com/ipython/ipython/issues/260>`_: Kernel crash with empty history
 * `243 <https://github.com/ipython/ipython/issues/243>`_: New display system
 * `242 <https://github.com/ipython/ipython/issues/242>`_: Fix terminal exit
 * `250 <https://github.com/ipython/ipython/issues/250>`_: always use Session.send
 * `239 <https://github.com/ipython/ipython/issues/239>`_: Makefile command & script for GitHub Pages
 * `244 <https://github.com/ipython/ipython/issues/244>`_: My exit
 * `234 <https://github.com/ipython/ipython/issues/234>`_: Timed history save
 * `217 <https://github.com/ipython/ipython/issues/217>`_: Doc magic lsmagic
 * `215 <https://github.com/ipython/ipython/issues/215>`_: History fix
 * `195 <https://github.com/ipython/ipython/issues/195>`_: Formatters
 * `192 <https://github.com/ipython/ipython/issues/192>`_: Ready colorize bug
 * `198 <https://github.com/ipython/ipython/issues/198>`_: Windows workdir
 * `174 <https://github.com/ipython/ipython/issues/174>`_: Whitespace cleanup
 * `188 <https://github.com/ipython/ipython/issues/188>`_: Version info: update our version management system to use git.
 * `158 <https://github.com/ipython/ipython/issues/158>`_: Ready for merge
 * `187 <https://github.com/ipython/ipython/issues/187>`_: Resolved Print shortcut collision with ctrl-P emacs binding
 * `183 <https://github.com/ipython/ipython/issues/183>`_: cleanup of exit/quit commands for qt console
 * `184 <https://github.com/ipython/ipython/issues/184>`_: Logo added to sphinx docs
 * `180 <https://github.com/ipython/ipython/issues/180>`_: Cleanup old code
 * `171 <https://github.com/ipython/ipython/issues/171>`_: Expose Pygments styles as options
 * `170 <https://github.com/ipython/ipython/issues/170>`_: HTML Fixes
 * `172 <https://github.com/ipython/ipython/issues/172>`_: Fix del method exit test
 * `164 <https://github.com/ipython/ipython/issues/164>`_: Qt frontend shutdown behavior fixes and enhancements
 * `167 <https://github.com/ipython/ipython/issues/167>`_: Added HTML export
 * `163 <https://github.com/ipython/ipython/issues/163>`_: Execution refactor
 * `159 <https://github.com/ipython/ipython/issues/159>`_: Ipy3 preparation
 * `155 <https://github.com/ipython/ipython/issues/155>`_: Ready startup fix
 * `152 <https://github.com/ipython/ipython/issues/152>`_: 0.10.1 sge
 * `151 <https://github.com/ipython/ipython/issues/151>`_: mk_object_info -> object_info
 * `149 <https://github.com/ipython/ipython/issues/149>`_: Simple bug-fix
 
 Regular issues (285):
 
 * `630 <https://github.com/ipython/ipython/issues/630>`_: new.py in pwd prevents ipython from starting
 * `623 <https://github.com/ipython/ipython/issues/623>`_: Execute DirectView commands while running LoadBalancedView tasks
 * `437 <https://github.com/ipython/ipython/issues/437>`_: Users should have autocompletion in the notebook
 * `583 <https://github.com/ipython/ipython/issues/583>`_: update manpages
 * `594 <https://github.com/ipython/ipython/issues/594>`_: irunner command line options defer to file extensions
 * `603 <https://github.com/ipython/ipython/issues/603>`_: Users should see colored text in tracebacks and the pager
 * `597 <https://github.com/ipython/ipython/issues/597>`_: UnicodeDecodeError: 'ascii' codec can't decode byte 0xc2
 * `608 <https://github.com/ipython/ipython/issues/608>`_: Organize and layout buttons in the notebook panel sections
 * `609 <https://github.com/ipython/ipython/issues/609>`_: Implement controls in the Kernel panel section
 * `611 <https://github.com/ipython/ipython/issues/611>`_: Add kernel status widget back to notebook
 * `610 <https://github.com/ipython/ipython/issues/610>`_: Implement controls in the Cell section panel
 * `612 <https://github.com/ipython/ipython/issues/612>`_: Implement Help panel section
 * `621 <https://github.com/ipython/ipython/issues/621>`_: [qtconsole] on windows xp, cannot  PageUp more than once
 * `616 <https://github.com/ipython/ipython/issues/616>`_: Store exit status of last command
 * `605 <https://github.com/ipython/ipython/issues/605>`_: Users should be able to open different notebooks in the cwd
 * `302 <https://github.com/ipython/ipython/issues/302>`_: Users should see a consistent behavior in the Out prompt in the html  notebook
 * `435 <https://github.com/ipython/ipython/issues/435>`_: Notebook should not import anything by default
 * `595 <https://github.com/ipython/ipython/issues/595>`_: qtconsole command issue
 * `588 <https://github.com/ipython/ipython/issues/588>`_: ipython-qtconsole uses 100% CPU
 * `586 <https://github.com/ipython/ipython/issues/586>`_: ? + plot() Command B0rks QTConsole Strangely
 * `585 <https://github.com/ipython/ipython/issues/585>`_: %pdoc throws Errors for classes without __init__ or docstring
 * `584 <https://github.com/ipython/ipython/issues/584>`_:  %pdoc throws TypeError
 * `580 <https://github.com/ipython/ipython/issues/580>`_: Client instantiation AssertionError
 * `569 <https://github.com/ipython/ipython/issues/569>`_: UnicodeDecodeError during startup
 * `572 <https://github.com/ipython/ipython/issues/572>`_: Indented command hits error
 * `573 <https://github.com/ipython/ipython/issues/573>`_: -wthread breaks indented top-level statements
 * `570 <https://github.com/ipython/ipython/issues/570>`_: "--pylab inline" vs. "--pylab=inline"
 * `566 <https://github.com/ipython/ipython/issues/566>`_: Can't use exec_file in config file
 * `562 <https://github.com/ipython/ipython/issues/562>`_: update docs to reflect '--args=values'
 * `558 <https://github.com/ipython/ipython/issues/558>`_: triple quote and %s at beginning of line
 * `554 <https://github.com/ipython/ipython/issues/554>`_: Update 0.11 docs to explain Qt console and how to do a clean install
 * `553 <https://github.com/ipython/ipython/issues/553>`_: embed() fails if config files not installed
 * `8 <https://github.com/ipython/ipython/issues/8>`_: Ensure %gui qt works with new Mayavi and pylab
 * `269 <https://github.com/ipython/ipython/issues/269>`_: Provide compatibility api for IPython.Shell().start().mainloop()
 * `66 <https://github.com/ipython/ipython/issues/66>`_: Update the main What's New document to reflect work on 0.11
 * `549 <https://github.com/ipython/ipython/issues/549>`_: Don't check for 'linux2' value in sys.platform
 * `505 <https://github.com/ipython/ipython/issues/505>`_: Qt windows created within imported functions won't show()
 * `545 <https://github.com/ipython/ipython/issues/545>`_: qtconsole ignores exec_lines
 * `371 <https://github.com/ipython/ipython/issues/371>`_: segfault in qtconsole when kernel quits
 * `377 <https://github.com/ipython/ipython/issues/377>`_: Failure: error (nothing to repeat)
 * `544 <https://github.com/ipython/ipython/issues/544>`_: Ipython qtconsole pylab config issue.
 * `543 <https://github.com/ipython/ipython/issues/543>`_: RuntimeError in completer 
 * `440 <https://github.com/ipython/ipython/issues/440>`_: %run filename autocompletion "The kernel heartbeat has been inactive ... " error
 * `541 <https://github.com/ipython/ipython/issues/541>`_: log_level is broken in the  ipython Application
 * `369 <https://github.com/ipython/ipython/issues/369>`_: windows source install doesn't create scripts correctly
 * `351 <https://github.com/ipython/ipython/issues/351>`_: Make sure that the Windows installer handles the top-level IPython scripts.
 * `512 <https://github.com/ipython/ipython/issues/512>`_: Two displayhooks in zmq
 * `340 <https://github.com/ipython/ipython/issues/340>`_: Make sure that the Windows HPC scheduler support is working for 0.11
 * `98 <https://github.com/ipython/ipython/issues/98>`_: Should be able to get help on an object mid-command
 * `529 <https://github.com/ipython/ipython/issues/529>`_: unicode problem in qtconsole for windows
 * `476 <https://github.com/ipython/ipython/issues/476>`_: Separate input area in Qt Console
 * `175 <https://github.com/ipython/ipython/issues/175>`_: Qt console needs configuration support
 * `156 <https://github.com/ipython/ipython/issues/156>`_: Key history lost when debugging program crash
 * `470 <https://github.com/ipython/ipython/issues/470>`_: decorator: uses deprecated features
 * `30 <https://github.com/ipython/ipython/issues/30>`_: readline in OS X does not have correct key bindings
 * `503 <https://github.com/ipython/ipython/issues/503>`_: merge IPython.parallel.streamsession and IPython.zmq.session
 * `456 <https://github.com/ipython/ipython/issues/456>`_: pathname in document punctuated by dots not slashes
 * `451 <https://github.com/ipython/ipython/issues/451>`_: Allow switching the default image format for inline mpl backend
 * `79 <https://github.com/ipython/ipython/issues/79>`_: Implement more robust handling of config stages in Application
 * `522 <https://github.com/ipython/ipython/issues/522>`_: Encoding problems
 * `524 <https://github.com/ipython/ipython/issues/524>`_: otool should not be unconditionally called on osx
 * `523 <https://github.com/ipython/ipython/issues/523>`_: Get profile and config file inheritance working
 * `519 <https://github.com/ipython/ipython/issues/519>`_: qtconsole --pure: "TypeError: string indices must be integers, not str"
 * `516 <https://github.com/ipython/ipython/issues/516>`_: qtconsole --pure: "KeyError: 'ismagic'"
 * `520 <https://github.com/ipython/ipython/issues/520>`_: qtconsole --pure: "TypeError: string indices must be integers, not str"
 * `450 <https://github.com/ipython/ipython/issues/450>`_: resubmitted tasks sometimes stuck as pending
 * `518 <https://github.com/ipython/ipython/issues/518>`_: JSON serialization problems with ObjectId type (MongoDB)
 * `178 <https://github.com/ipython/ipython/issues/178>`_: Channels should be named for their function, not their socket type
 * `515 <https://github.com/ipython/ipython/issues/515>`_: [ipcluster] termination on os x
 * `510 <https://github.com/ipython/ipython/issues/510>`_: qtconsole: indentation problem printing numpy arrays
 * `508 <https://github.com/ipython/ipython/issues/508>`_: "AssertionError: Missing message part." in ipython-qtconsole --pure
 * `499 <https://github.com/ipython/ipython/issues/499>`_: "ZMQError: Interrupted system call" when saving inline figure
 * `426 <https://github.com/ipython/ipython/issues/426>`_: %edit magic fails in qtconsole
 * `497 <https://github.com/ipython/ipython/issues/497>`_: Don't show info from .pyd files
 * `493 <https://github.com/ipython/ipython/issues/493>`_: QFont::setPointSize: Point size <= 0 (0), must be greater than 0
 * `489 <https://github.com/ipython/ipython/issues/489>`_: UnicodeEncodeError in qt.svg.save_svg
 * `458 <https://github.com/ipython/ipython/issues/458>`_: embed() doesn't load default config
 * `488 <https://github.com/ipython/ipython/issues/488>`_: Using IPython with RubyPython leads to problems with IPython.parallel.client.client.Client.__init()
 * `401 <https://github.com/ipython/ipython/issues/401>`_: Race condition when running lbview.apply() fast multiple times in loop
 * `168 <https://github.com/ipython/ipython/issues/168>`_: Scrub Launchpad links from code, docs
 * `141 <https://github.com/ipython/ipython/issues/141>`_: garbage collection problem (revisited)
 * `59 <https://github.com/ipython/ipython/issues/59>`_: test_magic.test_obj_del fails on win32
 * `457 <https://github.com/ipython/ipython/issues/457>`_: Backgrounded Tasks not Allowed?  (but easy to slip by . . .)
 * `297 <https://github.com/ipython/ipython/issues/297>`_: Shouldn't use pexpect for subprocesses in in-process terminal frontend
 * `110 <https://github.com/ipython/ipython/issues/110>`_: magic to return exit status
 * `473 <https://github.com/ipython/ipython/issues/473>`_: OSX readline detection fails in the debugger
 * `466 <https://github.com/ipython/ipython/issues/466>`_: tests fail without unicode filename support
 * `468 <https://github.com/ipython/ipython/issues/468>`_: iptest script has 0 exit code even when tests fail
 * `465 <https://github.com/ipython/ipython/issues/465>`_: client.db_query() behaves different with SQLite and MongoDB
 * `467 <https://github.com/ipython/ipython/issues/467>`_: magic_install_default_config test fails when there is no .ipython directory
 * `463 <https://github.com/ipython/ipython/issues/463>`_: IPYTHON_DIR (and IPYTHONDIR) don't expand tilde to '~' directory
 * `446 <https://github.com/ipython/ipython/issues/446>`_: Test machinery is imported at normal runtime
 * `438 <https://github.com/ipython/ipython/issues/438>`_: Users should be able to use Up/Down for cell navigation
 * `439 <https://github.com/ipython/ipython/issues/439>`_: Users should be able to copy notebook input and output
 * `291 <https://github.com/ipython/ipython/issues/291>`_: Rename special display methods and put them lower in priority than display functions
 * `447 <https://github.com/ipython/ipython/issues/447>`_: Instantiating classes without __init__ function causes kernel to crash
 * `444 <https://github.com/ipython/ipython/issues/444>`_: Ctrl + t in WxIPython Causes Unexpected Behavior
 * `445 <https://github.com/ipython/ipython/issues/445>`_: qt and console Based Startup Errors
 * `428 <https://github.com/ipython/ipython/issues/428>`_: ipcluster doesn't handle stale pid info well
 * `434 <https://github.com/ipython/ipython/issues/434>`_: 10.0.2 seg fault with rpy2
 * `441 <https://github.com/ipython/ipython/issues/441>`_: Allow running a block of code in a file
 * `432 <https://github.com/ipython/ipython/issues/432>`_: Silent request fails
 * `409 <https://github.com/ipython/ipython/issues/409>`_: Test failure in IPython.lib
 * `402 <https://github.com/ipython/ipython/issues/402>`_: History section of messaging spec is incorrect
 * `88 <https://github.com/ipython/ipython/issues/88>`_: Error when inputting UTF8 CJK characters
 * `366 <https://github.com/ipython/ipython/issues/366>`_: Ctrl-K should kill line and store it, so that Ctrl-y can yank it back
 * `425 <https://github.com/ipython/ipython/issues/425>`_: typo in %gui magic help
 * `304 <https://github.com/ipython/ipython/issues/304>`_: Persistent warnings if old configuration files exist
 * `216 <https://github.com/ipython/ipython/issues/216>`_: crash of ipython when alias is used with %s and echo
 * `412 <https://github.com/ipython/ipython/issues/412>`_: add support to automatic retry of tasks
 * `411 <https://github.com/ipython/ipython/issues/411>`_: add support to continue tasks
 * `417 <https://github.com/ipython/ipython/issues/417>`_: IPython should display things unsorted if it can't sort them
 * `416 <https://github.com/ipython/ipython/issues/416>`_: wrong encode when printing unicode string
 * `376 <https://github.com/ipython/ipython/issues/376>`_: Failing InputsplitterTest
 * `405 <https://github.com/ipython/ipython/issues/405>`_: TraitError in traitlets.py(332) on any input
 * `392 <https://github.com/ipython/ipython/issues/392>`_: UnicodeEncodeError on start
 * `137 <https://github.com/ipython/ipython/issues/137>`_: sys.getfilesystemencoding return value not checked
 * `300 <https://github.com/ipython/ipython/issues/300>`_: Users should be able to manage kernels and kernel sessions from the notebook UI
 * `301 <https://github.com/ipython/ipython/issues/301>`_: Users should have access to working Kernel, Tabs, Edit, Help menus in the notebook
 * `396 <https://github.com/ipython/ipython/issues/396>`_: cursor move triggers a lot of IO access
 * `379 <https://github.com/ipython/ipython/issues/379>`_: Minor doc nit: --paging argument
 * `399 <https://github.com/ipython/ipython/issues/399>`_: Add task queue limit in engine when load-balancing
 * `78 <https://github.com/ipython/ipython/issues/78>`_: StringTask won't take unicode code strings
 * `391 <https://github.com/ipython/ipython/issues/391>`_: MongoDB.add_record() does not work in 0.11dev
 * `365 <https://github.com/ipython/ipython/issues/365>`_: newparallel on Windows
 * `386 <https://github.com/ipython/ipython/issues/386>`_: FAIL: test that pushed functions have access to globals
 * `387 <https://github.com/ipython/ipython/issues/387>`_: Interactively defined functions can't access user namespace
 * `118 <https://github.com/ipython/ipython/issues/118>`_: Snow Leopard ipy_vimserver POLL error
 * `394 <https://github.com/ipython/ipython/issues/394>`_: System escape interpreted in multi-line string
 * `26 <https://github.com/ipython/ipython/issues/26>`_: find_job_cmd is too hasty to fail on Windows
 * `368 <https://github.com/ipython/ipython/issues/368>`_: Installation instructions in dev docs are completely wrong
 * `380 <https://github.com/ipython/ipython/issues/380>`_: qtconsole pager RST - HTML not happening consistently
 * `367 <https://github.com/ipython/ipython/issues/367>`_: Qt console doesn't support ibus input method
 * `375 <https://github.com/ipython/ipython/issues/375>`_: Missing libraries cause ImportError in tests
 * `71 <https://github.com/ipython/ipython/issues/71>`_: temp file errors in iptest IPython.core
 * `350 <https://github.com/ipython/ipython/issues/350>`_: Decide how to handle displayhook being triggered multiple times
 * `360 <https://github.com/ipython/ipython/issues/360>`_: Remove `runlines` method
 * `125 <https://github.com/ipython/ipython/issues/125>`_: Exec lines in config should not contribute to line numbering or history
 * `20 <https://github.com/ipython/ipython/issues/20>`_: Robust readline support on OS X's builtin Python
 * `147 <https://github.com/ipython/ipython/issues/147>`_: On Windows, %page is being too restrictive to split line by \r\n only
 * `326 <https://github.com/ipython/ipython/issues/326>`_: Update docs and examples for parallel stuff to reflect movement away from Twisted
 * `341 <https://github.com/ipython/ipython/issues/341>`_: FIx Parallel Magics for newparallel
 * `338 <https://github.com/ipython/ipython/issues/338>`_: Usability improvements to Qt console
 * `142 <https://github.com/ipython/ipython/issues/142>`_: unexpected auto-indenting when variables names that start with 'pass' 
 * `296 <https://github.com/ipython/ipython/issues/296>`_: Automatic PDB via %pdb doesn't work
 * `337 <https://github.com/ipython/ipython/issues/337>`_: exit( and quit( in Qt console produces phantom signature/docstring popup, even though quit() or exit() raises NameError
 * `318 <https://github.com/ipython/ipython/issues/318>`_: %debug broken in master: invokes missing save_history() method
 * `307 <https://github.com/ipython/ipython/issues/307>`_: lines ending with semicolon should not go to cache
 * `104 <https://github.com/ipython/ipython/issues/104>`_: have ipengine run start-up scripts before registering with the controller
 * `33 <https://github.com/ipython/ipython/issues/33>`_: The skip_doctest decorator is failing to work on Shell.MatplotlibShellBase.magic_run
 * `336 <https://github.com/ipython/ipython/issues/336>`_: Missing figure development/figs/iopubfade.png for docs
 * `49 <https://github.com/ipython/ipython/issues/49>`_: %clear should also delete _NN references and Out[NN] ones
 * `335 <https://github.com/ipython/ipython/issues/335>`_: using setuptools installs every script twice
 * `306 <https://github.com/ipython/ipython/issues/306>`_: multiline strings at end of input cause noop
 * `327 <https://github.com/ipython/ipython/issues/327>`_: PyPy compatibility
 * `328 <https://github.com/ipython/ipython/issues/328>`_: %run script.ipy raises "ERROR! Session/line number was not unique in database."
 * `7 <https://github.com/ipython/ipython/issues/7>`_: Update the changes doc to reflect the kernel config work
 * `303 <https://github.com/ipython/ipython/issues/303>`_: Users should be able to scroll a notebook w/o moving the menu/buttons
 * `322 <https://github.com/ipython/ipython/issues/322>`_: Embedding an interactive IPython shell 
 * `321 <https://github.com/ipython/ipython/issues/321>`_: %debug broken in master
 * `287 <https://github.com/ipython/ipython/issues/287>`_: Crash when using %macros in sqlite-history branch
 * `55 <https://github.com/ipython/ipython/issues/55>`_: Can't edit files whose names begin with numbers
 * `284 <https://github.com/ipython/ipython/issues/284>`_: In variable no longer works in 0.11
 * `92 <https://github.com/ipython/ipython/issues/92>`_: Using multiprocessing module crashes parallel IPython
 * `262 <https://github.com/ipython/ipython/issues/262>`_: Fail to recover history after force-kill.
 * `320 <https://github.com/ipython/ipython/issues/320>`_: Tab completing re.search objects crashes IPython
 * `317 <https://github.com/ipython/ipython/issues/317>`_: IPython.kernel: parallel map issues
 * `197 <https://github.com/ipython/ipython/issues/197>`_: ipython-qtconsole unicode problem in magic ls
 * `305 <https://github.com/ipython/ipython/issues/305>`_: more readline shortcuts in qtconsole
 * `314 <https://github.com/ipython/ipython/issues/314>`_: Multi-line, multi-block cells can't be executed.
 * `308 <https://github.com/ipython/ipython/issues/308>`_: Test suite should set sqlite history to work in :memory:
 * `202 <https://github.com/ipython/ipython/issues/202>`_: Matplotlib native 'MacOSX' backend broken in '-pylab' mode
 * `196 <https://github.com/ipython/ipython/issues/196>`_: IPython can't deal with unicode file name.
 * `25 <https://github.com/ipython/ipython/issues/25>`_: unicode bug - encoding input
 * `290 <https://github.com/ipython/ipython/issues/290>`_: try/except/else clauses can't be typed, code input stops too early.
 * `43 <https://github.com/ipython/ipython/issues/43>`_: Implement SSH support in ipcluster
 * `6 <https://github.com/ipython/ipython/issues/6>`_: Update the Sphinx docs for the new ipcluster
 * `9 <https://github.com/ipython/ipython/issues/9>`_: Getting "DeadReferenceError: Calling Stale Broker" after ipcontroller restart
 * `132 <https://github.com/ipython/ipython/issues/132>`_: Ipython prevent south from working
 * `27 <https://github.com/ipython/ipython/issues/27>`_: generics.complete_object broken
 * `60 <https://github.com/ipython/ipython/issues/60>`_: Improve absolute import management for iptest.py
 * `31 <https://github.com/ipython/ipython/issues/31>`_: Issues in magic_whos code
 * `52 <https://github.com/ipython/ipython/issues/52>`_: Document testing process better
 * `44 <https://github.com/ipython/ipython/issues/44>`_: Merge history from multiple sessions
 * `182 <https://github.com/ipython/ipython/issues/182>`_: ipython q4thread in version 10.1 not starting properly
 * `143 <https://github.com/ipython/ipython/issues/143>`_: Ipython.gui.wx.ipython_view.IPShellWidget: ignores user*_ns arguments
 * `127 <https://github.com/ipython/ipython/issues/127>`_: %edit does not work on filenames consisted of pure numbers
 * `126 <https://github.com/ipython/ipython/issues/126>`_: Can't transfer command line argument to script
 * `28 <https://github.com/ipython/ipython/issues/28>`_: Offer finer control for initialization of input streams
 * `58 <https://github.com/ipython/ipython/issues/58>`_: ipython change char '0xe9' to 4 spaces
 * `68 <https://github.com/ipython/ipython/issues/68>`_: Problems with Control-C stopping ipcluster on Windows/Python2.6
 * `24 <https://github.com/ipython/ipython/issues/24>`_: ipcluster does not start all the engines
 * `240 <https://github.com/ipython/ipython/issues/240>`_: Incorrect method displayed in %psource
 * `120 <https://github.com/ipython/ipython/issues/120>`_: inspect.getsource fails for functions defined on command line
 * `212 <https://github.com/ipython/ipython/issues/212>`_: IPython ignores exceptions in the first evaulation of class attrs
 * `108 <https://github.com/ipython/ipython/issues/108>`_: ipython disables python logger
 * `100 <https://github.com/ipython/ipython/issues/100>`_: Overzealous introspection
 * `18 <https://github.com/ipython/ipython/issues/18>`_: %cpaste freeze sync frontend
 * `200 <https://github.com/ipython/ipython/issues/200>`_: Unicode error when starting ipython in a folder with non-ascii path
 * `130 <https://github.com/ipython/ipython/issues/130>`_: Deadlock when importing a module that creates an IPython client
 * `134 <https://github.com/ipython/ipython/issues/134>`_: multline block scrolling
 * `46 <https://github.com/ipython/ipython/issues/46>`_: Input to %timeit is not preparsed
 * `285 <https://github.com/ipython/ipython/issues/285>`_: ipcluster local -n 4 fails
 * `205 <https://github.com/ipython/ipython/issues/205>`_: In the Qt console, Tab should insert 4 spaces when not completing
 * `145 <https://github.com/ipython/ipython/issues/145>`_: Bug on MSW systems: idle can not be set as default IPython editor. Fix Suggested.
 * `77 <https://github.com/ipython/ipython/issues/77>`_: ipython oops in cygwin
 * `121 <https://github.com/ipython/ipython/issues/121>`_: If plot windows are closed via window controls, no more plotting is possible.
 * `111 <https://github.com/ipython/ipython/issues/111>`_: Iterator version of TaskClient.map() that returns results as they become available
 * `109 <https://github.com/ipython/ipython/issues/109>`_: WinHPCLauncher is a hard dependency that causes errors in the test suite
 * `86 <https://github.com/ipython/ipython/issues/86>`_: Make IPython work with multiprocessing
 * `15 <https://github.com/ipython/ipython/issues/15>`_: Implement SGE support in ipcluster
 * `3 <https://github.com/ipython/ipython/issues/3>`_: Implement PBS support in ipcluster
 * `53 <https://github.com/ipython/ipython/issues/53>`_: Internal Python error in the inspect module
 * `74 <https://github.com/ipython/ipython/issues/74>`_: Manager() [from multiprocessing module] hangs ipythonx but not ipython
 * `51 <https://github.com/ipython/ipython/issues/51>`_: Out not working with ipythonx
 * `201 <https://github.com/ipython/ipython/issues/201>`_: use session.send throughout zmq code
 * `115 <https://github.com/ipython/ipython/issues/115>`_: multiline specials not defined in 0.11 branch
 * `93 <https://github.com/ipython/ipython/issues/93>`_: when looping, cursor appears at leftmost point in newline
 * `133 <https://github.com/ipython/ipython/issues/133>`_: whitespace after Source introspection
 * `50 <https://github.com/ipython/ipython/issues/50>`_: Ctrl-C with -gthread on Windows, causes uncaught IOError
 * `65 <https://github.com/ipython/ipython/issues/65>`_: Do not use .message attributes in exceptions, deprecated in 2.6
 * `76 <https://github.com/ipython/ipython/issues/76>`_: syntax error when raise is inside except process
 * `107 <https://github.com/ipython/ipython/issues/107>`_: bdist_rpm causes traceback looking for a non-existant file
 * `113 <https://github.com/ipython/ipython/issues/113>`_: initial magic ? (question mark) fails before wildcard
 * `128 <https://github.com/ipython/ipython/issues/128>`_: Pdb instance has no attribute 'curframe'
 * `139 <https://github.com/ipython/ipython/issues/139>`_: running with -pylab pollutes namespace
 * `140 <https://github.com/ipython/ipython/issues/140>`_: malloc error during tab completion of numpy array member functions starting with 'c'
 * `153 <https://github.com/ipython/ipython/issues/153>`_: ipy_vimserver traceback on Windows
 * `154 <https://github.com/ipython/ipython/issues/154>`_: using ipython in Slicer3 show how os.environ['HOME'] is not defined
 * `185 <https://github.com/ipython/ipython/issues/185>`_: show() blocks in pylab mode with ipython 0.10.1 
 * `189 <https://github.com/ipython/ipython/issues/189>`_: Crash on tab completion
 * `274 <https://github.com/ipython/ipython/issues/274>`_: bashism in sshx.sh
 * `276 <https://github.com/ipython/ipython/issues/276>`_: Calling `sip.setapi` does not work if app has already imported from PyQt4
 * `277 <https://github.com/ipython/ipython/issues/277>`_: matplotlib.image imgshow from 10.1 segfault
 * `288 <https://github.com/ipython/ipython/issues/288>`_: Incorrect docstring in zmq/kernelmanager.py
 * `286 <https://github.com/ipython/ipython/issues/286>`_: Fix IPython.Shell compatibility layer
 * `99 <https://github.com/ipython/ipython/issues/99>`_: blank lines in history
 * `129 <https://github.com/ipython/ipython/issues/129>`_: psearch: TypeError: expected string or buffer
 * `190 <https://github.com/ipython/ipython/issues/190>`_: Add option to format float point output
 * `246 <https://github.com/ipython/ipython/issues/246>`_: Application not conforms XDG Base Directory Specification
 * `48 <https://github.com/ipython/ipython/issues/48>`_: IPython should follow the XDG Base Directory spec for configuration
 * `176 <https://github.com/ipython/ipython/issues/176>`_: Make client-side history persistence readline-independent
 * `279 <https://github.com/ipython/ipython/issues/279>`_: Backtraces when using ipdb do not respect -colour LightBG setting
 * `119 <https://github.com/ipython/ipython/issues/119>`_: Broken type filter in magic_who_ls
 * `271 <https://github.com/ipython/ipython/issues/271>`_: Intermittent problem with print output in Qt console.
 * `270 <https://github.com/ipython/ipython/issues/270>`_: Small typo in IPython developer’s guide
 * `166 <https://github.com/ipython/ipython/issues/166>`_: Add keyboard accelerators to Qt close dialog
 * `173 <https://github.com/ipython/ipython/issues/173>`_: asymmetrical ctrl-A/ctrl-E behavior in multiline
 * `45 <https://github.com/ipython/ipython/issues/45>`_: Autosave history for robustness
 * `162 <https://github.com/ipython/ipython/issues/162>`_: make command history persist in ipythonqt
 * `161 <https://github.com/ipython/ipython/issues/161>`_: make ipythonqt exit without dialog when exit() is called
 * `263 <https://github.com/ipython/ipython/issues/263>`_: [ipython + numpy] Some test errors 
 * `256 <https://github.com/ipython/ipython/issues/256>`_: reset docstring ipython 0.10 
 * `258 <https://github.com/ipython/ipython/issues/258>`_: allow caching to avoid matplotlib object references
 * `248 <https://github.com/ipython/ipython/issues/248>`_: Can't open and read files after upgrade from 0.10 to 0.10.0
 * `247 <https://github.com/ipython/ipython/issues/247>`_: ipython + Stackless
 * `245 <https://github.com/ipython/ipython/issues/245>`_: Magic save and macro missing newlines, line ranges don't match prompt numbers.
 * `241 <https://github.com/ipython/ipython/issues/241>`_: "exit" hangs on terminal version of IPython
 * `213 <https://github.com/ipython/ipython/issues/213>`_: ipython -pylab no longer plots interactively on 0.10.1
 * `4 <https://github.com/ipython/ipython/issues/4>`_: wx frontend don't display well commands output
 * `5 <https://github.com/ipython/ipython/issues/5>`_: ls command not supported in ipythonx wx frontend
 * `1 <https://github.com/ipython/ipython/issues/1>`_: Document winhpcjob.py and launcher.py
 * `83 <https://github.com/ipython/ipython/issues/83>`_: Usage of testing.util.DeferredTestCase should be replace with twisted.trial.unittest.TestCase
 * `117 <https://github.com/ipython/ipython/issues/117>`_: Redesign how Component instances are tracked and queried
 * `47 <https://github.com/ipython/ipython/issues/47>`_: IPython.kernel.client cannot be imported inside an engine
 * `105 <https://github.com/ipython/ipython/issues/105>`_: Refactor the task dependencies system
 * `210 <https://github.com/ipython/ipython/issues/210>`_: 0.10.1 doc mistake - New IPython Sphinx directive error
 * `209 <https://github.com/ipython/ipython/issues/209>`_: can't activate IPython parallel magics
 * `206 <https://github.com/ipython/ipython/issues/206>`_: Buggy linewrap in Mac OSX Terminal
 * `194 <https://github.com/ipython/ipython/issues/194>`_: !sudo <command> displays password in plain text
 * `186 <https://github.com/ipython/ipython/issues/186>`_: %edit issue under OS X 10.5 - IPython 0.10.1
 * `11 <https://github.com/ipython/ipython/issues/11>`_: Create a daily build PPA for ipython
 * `144 <https://github.com/ipython/ipython/issues/144>`_: logo missing from sphinx docs
 * `181 <https://github.com/ipython/ipython/issues/181>`_: cls command does not work on windows
 * `169 <https://github.com/ipython/ipython/issues/169>`_: Kernel can only be bound to localhost
 * `36 <https://github.com/ipython/ipython/issues/36>`_: tab completion does not escape ()
 * `177 <https://github.com/ipython/ipython/issues/177>`_: Report tracebacks of interactively entered input
 * `148 <https://github.com/ipython/ipython/issues/148>`_: dictionary having multiple keys having frozenset fails to print on IPython
 * `160 <https://github.com/ipython/ipython/issues/160>`_: magic_gui throws TypeError when gui magic is used
 * `150 <https://github.com/ipython/ipython/issues/150>`_: History entries ending with parentheses corrupt command line on OS X 10.6.4
 * `146 <https://github.com/ipython/ipython/issues/146>`_: -ipythondir - using an alternative .ipython dir for rc type stuff
 * `114 <https://github.com/ipython/ipython/issues/114>`_: Interactive strings get mangled with "_ip.magic"
 * `135 <https://github.com/ipython/ipython/issues/135>`_: crash on  invalid print
 * `69 <https://github.com/ipython/ipython/issues/69>`_: Usage of "mycluster" profile in docs and examples
 * `37 <https://github.com/ipython/ipython/issues/37>`_: Fix colors in output of ResultList on Windows

docs/source/whatsnew/github-stats-2.0.rst

@@ -1,1607 +1,1607 b''
 .. _issues_list_200:
 
 Issues closed in the 2.x development cycle
 ==========================================
 
 Issues closed in 2.4.1
 ----------------------
 
 GitHub stats for 2014/11/01 - 2015/01/30
 
 .. note::
 
     IPython 2.4.0 was released without a few of the backports listed below.
     2.4.1 has the correct patches intended for 2.4.0.
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 The following 7 authors contributed 35 commits.
 
 * Benjamin Ragan-Kelley
 * Carlos Cordoba
 * Damon Allen
 * Jessica B. Hamrick
 * Mateusz Paprocki
 * Peter Würtz
 * Thomas Kluyver
 
 We closed 10 issues and merged 6 pull requests;
 this is the full list (generated with the script 
 :file:`tools/github_stats.py`):
 
 Pull Requests (10):
 
 * :ghpull:`7106`: Changed the display order of rich output in the live notebook.
 * :ghpull:`6878`: Update pygments monkeypatch for compatibility with Pygments 2.0
 * :ghpull:`6778`: backport nbformat v4 to 2.x
 * :ghpull:`6761`: object_info_reply field is oname, not name
 * :ghpull:`6653`: Fix IPython.utils.ansispan() to ignore stray [0m
 * :ghpull:`6706`: Correctly display prompt numbers that are ``None``
 * :ghpull:`6634`: don't use contains in SelectWidget item_query
 * :ghpull:`6593`: note how to start the qtconsole
 * :ghpull:`6281`: more minor fixes to release scripts
 * :ghpull:`5458`: Add support for PyQt5.
 
 Issues (6):
 
 * :ghissue:`7272`: qtconsole problems with pygments
 * :ghissue:`7049`: Cause TypeError: 'NoneType' object is not callable in qtconsole 
 * :ghissue:`6877`: Qt console doesn't work with pygments 2.0rc1
 * :ghissue:`6689`: Problem with string containing two or more question marks
 * :ghissue:`6702`: Cell numbering after ``ClearOutput`` preprocessor
 * :ghissue:`6633`: selectwidget doesn't display 1 as a selection choice when passed in as a member of values list
 
 
 Issues closed in 2.3.1
 ----------------------
 
 Just one bugfix: fixed bad CRCRLF line-endings in notebooks on Windows
 
 Pull Requests (1):
 
 * :ghpull:`6911`: don't use text mode in mkstemp
 
 Issues (1):
 
 * :ghissue:`6599`: Notebook.ipynb CR+LF turned into CR+CR+LF
 
 
 Issues closed in 2.3.0
 ----------------------
 
 GitHub stats for 2014/08/06 - 2014/10/01
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 The following 6 authors contributed 31 commits.
 
 * Benjamin Ragan-Kelley
 * David Hirschfeld
 * Eric Firing
 * Jessica B. Hamrick
 * Matthias Bussonnier
 * Thomas Kluyver
 
 We closed 16 issues and merged 9 pull requests;
 this is the full list (generated with the script 
 :file:`tools/github_stats.py`):
 
 Pull Requests (16):
 
 * :ghpull:`6587`: support ``%matplotlib qt5`` and ``%matplotlib nbagg``
 * :ghpull:`6583`: Windows symlink test fixes
 * :ghpull:`6585`: fixes :ghissue:`6473`
 * :ghpull:`6581`: Properly mock winreg functions for test
 * :ghpull:`6556`: Use some more informative asserts in inprocess kernel tests
 * :ghpull:`6514`: Fix for copying metadata flags
 * :ghpull:`6453`: Copy file metadata in atomic save
 * :ghpull:`6480`: only compare host:port in Websocket.check_origin
 * :ghpull:`6483`: Trim anchor link in heading cells, fixes :ghissue:`6324`
 * :ghpull:`6410`: Fix relative import in appnope
 * :ghpull:`6395`: update mathjax CDN url in nbconvert template
 * :ghpull:`6269`: Implement atomic save
 * :ghpull:`6374`: Rename ``abort_queues`` --> ``_abort_queues``
 * :ghpull:`6321`: Use appnope in qt and wx gui support from the terminal; closes :ghissue:`6189`
 * :ghpull:`6318`: use write_error instead of get_error_html
 * :ghpull:`6303`: Fix error message when failing to load a notebook
 
 Issues (9):
 
 * :ghissue:`6057`: ``%matplotlib`` + qt5
 * :ghissue:`6518`: Test failure in atomic save on Windows
 * :ghissue:`6473`: Switching between "Raw Cell Format" and "Edit Metadata" does not work
 * :ghissue:`6405`: Creating a notebook should respect directory permissions; saving should respect prior permissions
 * :ghissue:`6324`: Anchors in Heading don't work.
 * :ghissue:`6409`: No module named '_dummy'
 * :ghissue:`6392`: Mathjax library link broken
 * :ghissue:`6329`: IPython Notebook Server URL now requires "tree" at the end of the URL? (version 2.2)
 * :ghissue:`6189`: ipython console freezes for increasing no of seconds in %pylab mode
 
 Issues closed in 2.2.0
 ----------------------
 
 GitHub stats for 2014/05/21 - 2014/08/06 (tag: rel-2.1.0)
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 The following 13 authors contributed 36 commits.
 
 * Adam Hodgen
 * Benjamin Ragan-Kelley
 * Björn Grüning
 * Dara Adib
 * Eric Galloway
 * Jonathan Frederic
 * Kyle Kelley
 * Matthias Bussonnier
 * Paul Ivanov
 * Shayne Hodge
 * Steven Anton
 * Thomas Kluyver
 * Zahari
 
 We closed 23 issues and merged 11 pull requests;
 this is the full list (generated with the script 
 :file:`tools/github_stats.py`):
 
 Pull Requests (23):
 
 * :ghpull:`6279`: minor updates to release scripts
 * :ghpull:`6273`: Upgrade default mathjax version.
 * :ghpull:`6249`: always use HTTPS getting mathjax from CDN
 * :ghpull:`6114`: update hmac signature comparison
 * :ghpull:`6195`: Close handle on new temporary files before returning filename
 * :ghpull:`6143`: pin tornado to < 4 on travis js tests
 * :ghpull:`6134`: remove rackcdn https workaround for mathjax cdn
 * :ghpull:`6120`: Only allow iframe embedding on same origin.
 * :ghpull:`6117`: Remove / from route of TreeRedirectHandler.
 * :ghpull:`6105`: only set allow_origin_pat if defined
 * :ghpull:`6102`: Add newline if missing to end of script magic cell
 * :ghpull:`6077`: allow unicode keys in dicts in json_clean
 * :ghpull:`6061`: make CORS configurable
 * :ghpull:`6081`: don’t modify dict keys while iterating through them
 * :ghpull:`5803`: unify visual line handling
 * :ghpull:`6005`: Changed right arrow key movement function to mirror left arrow key
 * :ghpull:`6029`: add pickleutil.PICKLE_PROTOCOL
 * :ghpull:`6003`: Set kernel_id before checking websocket
 * :ghpull:`5994`: Fix ssh tunnel for Python3
 * :ghpull:`5973`: Do not create checkpoint_dir relative to current dir
 * :ghpull:`5933`: fix qt_loader import hook signature
 * :ghpull:`5944`: Markdown rendering bug fix.
 * :ghpull:`5917`: use shutil.move instead of os.rename
 
 Issues (11):
 
 * :ghissue:`6246`: Include MathJax by default or access the CDN over a secure connection
 * :ghissue:`5525`: Websocket origin check fails when used with Apache WS proxy
 * :ghissue:`5901`: 2 test failures in Python 3.4 in parallel group
 * :ghissue:`5926`: QT console: text selection cannot be made from left to right with keyboard
 * :ghissue:`5998`: use_dill does not work in Python 3.4
 * :ghissue:`5964`: Traceback on Qt console exit
 * :ghissue:`5787`: Error in Notebook-Generated latex (nbconvert)
 * :ghissue:`5950`: qtconsole truncates help
 * :ghissue:`5943`: 2.x: notebook fails to load when using HTML comments
 * :ghissue:`5932`: Qt ImportDenier Does Not Adhere to PEP302
 * :ghissue:`5898`: OSError when moving configuration file
 
 Issues closed in 2.1.0
 ----------------------
 
 GitHub stats for 2014/04/02 - 2014/05/21 (since 2.0.0)
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 The following 35 authors contributed 145 commits.
 
 * Adrian Price-Whelan
 * Aron Ahmadia
 * Benjamin Ragan-Kelley
 * Benjamin Schultz
 * Björn Linse
 * Blake Griffith
 * chebee7i
 * Damián Avila
 * Dav Clark
 * dexterdev
 * Erik Tollerud
 * Grzegorz Rożniecki
 * Jakob Gager
 * jdavidheiser
 * Jessica B. Hamrick
 * Jim Garrison
 * Jonathan Frederic
 * Matthias Bussonnier
 * Maximilian Albert
 * Mohan Raj Rajamanickam
 * ncornette
 * Nikolay Koldunov
 * Nile Geisinger
 * Pankaj Pandey
 * Paul Ivanov
 * Pierre Haessig
 * Raffaele De Feo
 * Renaud Richardet
 * Spencer Nelson
 * Steve Chan
 * sunny
 * Susan Tan
 * Thomas Kluyver
 * Yaroslav Halchenko
 * zah
 
 We closed a total of 129 issues, 92 pull requests and 37 regular issues;
 this is the full list (generated with the script 
 :file:`tools/github_stats.py --milestone 2.1`):
 
 Pull Requests (92):
 
 * :ghpull:`5871`: specify encoding in msgpack.unpackb
 * :ghpull:`5869`: Catch more errors from clipboard access on Windows
 * :ghpull:`5866`: Make test robust against differences in line endings
 * :ghpull:`5605`: Two cell toolbar fixes.
 * :ghpull:`5843`: remove Firefox-specific CSS workaround
 * :ghpull:`5845`: Pass Windows interrupt event to kernels as an environment variable
 * :ghpull:`5835`: fix typo in v2 convert
 * :ghpull:`5841`: Fix writing history with output to a file in Python 2
 * :ghpull:`5842`: fix typo in nbconvert help
 * :ghpull:`5846`: Fix typos in Cython example
 * :ghpull:`5839`: Close graphics dev in finally clause
 * :ghpull:`5837`: pass on install docs
 * :ghpull:`5832`: Fixed example to work with python3
 * :ghpull:`5826`: allow notebook tour instantiation to fail
 * :ghpull:`5560`: Minor expansion of Cython example
 * :ghpull:`5818`: interpret any exception in getcallargs as not callable
 * :ghpull:`5816`: Add output to IPython directive when in verbatim mode.
 * :ghpull:`5822`: Don't overwrite widget description in interact
 * :ghpull:`5782`: Silence exception thrown by completer when dir() does not return a list
 * :ghpull:`5807`: Drop log level to info for Qt console shutdown
 * :ghpull:`5814`: Remove -i options from mv, rm and cp aliases
 * :ghpull:`5812`: Fix application name when printing subcommand help.
 * :ghpull:`5804`: remove an inappropriate ``!``
 * :ghpull:`5805`: fix engine startup files
 * :ghpull:`5806`: Don't auto-move .config/ipython if symbolic link
 * :ghpull:`5716`: Add booktabs package to latex base.tplx
 * :ghpull:`5669`: allows threadsafe sys.stdout.flush from background threads
 * :ghpull:`5668`: allow async output on the most recent request
 * :ghpull:`5768`: fix cursor keys in long lines wrapped in markdown
 * :ghpull:`5788`: run cells with ``silent=True`` in ``%run nb.ipynb``
 * :ghpull:`5715`: log all failed ajax API requests
 * :ghpull:`5769`: Don't urlescape the text that goes into a title tag
 * :ghpull:`5762`: Fix check for pickling closures
 * :ghpull:`5766`: View.map with empty sequence should return empty list
 * :ghpull:`5758`: Applied bug fix: using fc and ec did not properly set the figure canvas ...
 * :ghpull:`5754`: Format command name into subcommand_description at run time, not import
 * :ghpull:`5744`: Describe using PyPI/pip to distribute & install extensions
 * :ghpull:`5712`: monkeypatch inspect.findsource only when we use it
 * :ghpull:`5708`: create checkpoints dir in notebook subdirectories
 * :ghpull:`5714`: log error message when API requests fail
 * :ghpull:`5732`: Quick typo fix in nbformat/convert.py
 * :ghpull:`5713`: Fix a NameError in IPython.parallel
 * :ghpull:`5704`: Update nbconvertapp.py
 * :ghpull:`5534`: cleanup some ``pre`` css inheritance
 * :ghpull:`5699`: don't use common names in require decorators
 * :ghpull:`5692`: Update notebook.rst fixing broken reference to notebook examples readme
 * :ghpull:`5693`: Update parallel_intro.rst to fix a broken link to examples
 * :ghpull:`5486`: disambiguate to location when no IPs can be determined
 * :ghpull:`5574`: Remove the outdated keyboard shortcuts from notebook docs
 * :ghpull:`5568`: Use ``__qualname__`` in pretty reprs for Python 3
 * :ghpull:`5678`: Fix copy & paste error in docstring of ImageWidget class
 * :ghpull:`5677`: Fix %bookmark -l for Python 3
 * :ghpull:`5670`: nbconvert: Fix CWD imports
 * :ghpull:`5647`: Mention git hooks in install documentation
 * :ghpull:`5671`: Fix blank slides issue in Reveal slideshow pdf export
 * :ghpull:`5657`: use 'localhost' as default for the notebook server
 * :ghpull:`5584`: more semantic icons
 * :ghpull:`5594`: update components with marked-0.3.2
 * :ghpull:`5500`: check for Python 3.2
 * :ghpull:`5582`: reset readline after running PYTHONSTARTUP
 * :ghpull:`5630`: Fixed Issue :ghissue:`4012` Added Help menubar link to Github markdown doc
 * :ghpull:`5613`: Fixing bug :ghissue:`5607`
 * :ghpull:`5633`: Provide more help if lessc is not found.
 * :ghpull:`5620`: fixed a typo in IPython.core.formatters
 * :ghpull:`5619`: Fix typo in storemagic module docstring
 * :ghpull:`5592`: add missing ``browser`` to notebook_aliases list
 * :ghpull:`5506`: Fix ipconfig regex pattern
 * :ghpull:`5581`: Fix rmagic for cells ending in comment.
 * :ghpull:`5576`: only process cr if it's found
 * :ghpull:`5478`: Add git-hooks install script. Update README.md
 * :ghpull:`5546`: do not shutdown notebook if 'n' is part of answer
 * :ghpull:`5527`: Don't remove upload items from nav tree unless explicitly requested.
 * :ghpull:`5501`: remove inappropriate wheel tag override
 * :ghpull:`5548`: FileNotebookManager: Use shutil.move() instead of os.rename()
 * :ghpull:`5524`: never use ``for (var i in array)``
 * :ghpull:`5459`: Fix interact animation page jump FF
 * :ghpull:`5559`: Minor typo fix in "Cython Magics.ipynb"
 * :ghpull:`5507`: Fix typo in interactive widgets examples index notebook
 * :ghpull:`5554`: Make HasTraits pickleable
 * :ghpull:`5535`: fix n^2 performance issue in coalesce_streams preprocessor
 * :ghpull:`5522`: fix iteration over Client
 * :ghpull:`5488`: Added missing require and jquery from cdn.
 * :ghpull:`5516`: ENH: list generated config files in generated, and rm them upon clean
 * :ghpull:`5493`: made a minor fix to one of the widget examples
 * :ghpull:`5512`: Update tooltips to refer to shift-tab
 * :ghpull:`5505`: Make backport_pr work on Python 3
 * :ghpull:`5503`: check explicitly for 'dev' before adding the note to docs
 * :ghpull:`5498`: use milestones to indicate backport
 * :ghpull:`5492`: Polish whatsnew docs
 * :ghpull:`5495`: Fix various broken things in docs
 * :ghpull:`5496`: Exclude whatsnew/pr directory from docs builds
 * :ghpull:`5489`: Fix required Python versions
 
 Issues (37):
 
 * :ghissue:`5364`: Horizontal scrollbar hides cell's last line on Firefox
 * :ghissue:`5192`: horisontal scrollbar overlaps output or touches next cell
 * :ghissue:`5840`: Third-party Windows kernels don't get interrupt signal
 * :ghissue:`2412`: print history to file using qtconsole and notebook
 * :ghissue:`5703`: Notebook doesn't render with "ask me every time" cookie setting in Firefox
 * :ghissue:`5817`: calling mock object in IPython 2.0.0 under Python 3.4.0 raises AttributeError
 * :ghissue:`5499`: Error running widgets nbconvert example
 * :ghissue:`5654`: Broken links from ipython documentation
 * :ghissue:`5019`: print in QT event callback doesn't show up in ipython notebook.
 * :ghissue:`5800`: Only last In prompt number set ?
 * :ghissue:`5801`: startup_command specified in ipengine_config.py is not executed
 * :ghissue:`5690`: ipython 2.0.0 and pandoc 1.12.2.1 problem
 * :ghissue:`5408`: Add checking/flushing of background output from kernel in mainloop
 * :ghissue:`5407`: clearing message handlers on status=idle loses async output
 * :ghissue:`5467`: Incorrect behavior of up/down keyboard arrows in code cells on wrapped lines
 * :ghissue:`3085`: nicer notebook error message when lacking permissions
 * :ghissue:`5765`: map_sync over empty list raises IndexError
 * :ghissue:`5553`: Notebook matplotlib inline backend: can't set figure facecolor
 * :ghissue:`5710`: inspect.findsource monkeypatch raises wrong exception for C extensions
 * :ghissue:`5706`: Multi-Directory notebooks overwrite each other's checkpoints
 * :ghissue:`5698`: can't require a function named ``f``
 * :ghissue:`5569`: Keyboard shortcuts in documentation are out of date
 * :ghissue:`5566`: Function name printing should use ``__qualname__`` instead of ``__name__`` (Python 3)
 * :ghissue:`5676`: "bookmark -l" not working in ipython 2.0
 * :ghissue:`5555`: Differentiate more clearly between Notebooks and Folders in new UI
 * :ghissue:`5590`: Marked double escape 
 * :ghissue:`5514`: import tab-complete fail with ipython 2.0 shell
 * :ghissue:`4012`: Notebook: link to markdown formatting reference
 * :ghissue:`5611`: Typo in 'storemagic' documentation
 * :ghissue:`5589`: Kernel start fails when using --browser argument
 * :ghissue:`5491`: Bug in Windows ipconfig ip address regular expression  
 * :ghissue:`5579`: rmagic extension throws 'Error while parsing the string.' when last line is comment
 * :ghissue:`5518`: Ipython2 will not open ipynb in example directory
 * :ghissue:`5561`: New widget documentation has missing notebook link
 * :ghissue:`5128`: Page jumping when output from widget interaction replaced
 * :ghissue:`5519`: IPython.parallel.Client behavior as iterator
 * :ghissue:`5510`: Tab-completion for function argument list
 
 
 Issues closed in 2.0.0
 ----------------------
 
 
 GitHub stats for 2013/08/09 - 2014/04/01 (since 1.0.0)
 
 These lists are automatically generated, and may be incomplete or contain duplicates.
 
 The following 94 authors contributed 3949 commits.
 
 * Aaron Meurer
 * Abhinav Upadhyay
 * Adam Riggall
 * Alex Rudy
 * Andrew Mark
 * Angus Griffith
 * Antony Lee
 * Aron Ahmadia
 * Arun Persaud
 * Benjamin Ragan-Kelley
 * Bing Xia
 * Blake Griffith
 * Bouke van der Bijl
 * Bradley M. Froehle
 * Brian E. Granger
 * Carlos Cordoba
 * chapmanb
 * chebee7i
 * Christoph Gohlke
 * Christophe Pradal
 * Cyrille Rossant
 * Damián Avila
 * Daniel B. Vasquez
 * Dav Clark
 * David Hirschfeld
 * David P. Sanders
 * David Wyde
 * David Österberg
 * Doug Blank
 * Dražen Lučanin
 * epifanio
 * Fernando Perez
 * Gabriel Becker
 * Geert Barentsen
 * Hans Meine
 * Ingolf Becker
 * Jake Vanderplas
 * Jakob Gager
 * James Porter
 * Jason Grout
 * Jeffrey Tratner
 * Jonah Graham
 * Jonathan Frederic
 * Joris Van den Bossche
 * Juergen Hasch
 * Julian Taylor
 * Katie Silverio
 * Kevin Burke
 * Kieran O'Mahony
 * Konrad Hinsen
 * Kyle Kelley
 * Lawrence Fu
 * Marc Molla
 * Martín Gaitán
 * Matt Henderson
 * Matthew Brett
 * Matthias Bussonnier
 * Michael Droettboom
 * Mike McKerns
 * Nathan Goldbaum
 * Pablo de Oliveira
 * Pankaj Pandey
 * Pascal Schetelat
 * Paul Ivanov
 * Paul Moore
 * Pere Vilas
 * Peter Davis
 * Philippe Mallet-Ladeira
 * Preston Holmes
 * Puneeth Chaganti
 * Richard Everson
 * Roberto Bonvallet
 * Samuel Ainsworth
 * Sean Vig
 * Shashi Gowda
 * Skipper Seabold
 * Stephan Rave
 * Steve Fox
 * Steven Silvester
 * stonebig
 * Susan Tan
 * Sylvain Corlay
 * Takeshi Kanmae
 * Ted Drain
 * Thomas A Caswell
 * Thomas Kluyver
 * Théophile Studer
 * Volker Braun
 * Wieland Hoffmann
 * Yaroslav Halchenko
 * Yoval P.
 * Yung Siang Liau
 * Zachary Sailer
 * zah
 
 
 We closed a total of 1121 issues, 687 pull requests and 434 regular issues;
 this is the full list (generated with the script 
 :file:`tools/github_stats.py`):
 
 Pull Requests (687):
 
 * :ghpull:`5487`: remove weird unicode space in the new copyright header
 * :ghpull:`5476`: For 2.0: Fix links in Notebook Help Menu
 * :ghpull:`5337`: Examples reorganization
 * :ghpull:`5436`: CodeMirror shortcuts in QuickHelp
 * :ghpull:`5444`: Fix numeric verification for Int and Float text widgets.
 * :ghpull:`5449`: Stretch keyboard shortcut dialog
 * :ghpull:`5473`: Minor corrections of git-hooks setup instructions
 * :ghpull:`5471`: Add coding magic comment to nbconvert Python template
 * :ghpull:`5452`: print_figure returns unicode for svg
 * :ghpull:`5450`: proposal: remove codename
 * :ghpull:`5462`: DOC : fixed minor error in using topological sort
 * :ghpull:`5463`: make spin_thread tests more forgiving of slow VMs
 * :ghpull:`5464`: Fix starting notebook server with file/directory at command line.
 * :ghpull:`5453`: remove gitwash
 * :ghpull:`5454`: Improve history API docs
 * :ghpull:`5431`: update github_stats and gh_api for 2.0
 * :ghpull:`5290`: Add dual mode JS tests
 * :ghpull:`5451`: check that a handler is actually registered in ShortcutManager.handles
 * :ghpull:`5447`: Add %%python2 cell magic
 * :ghpull:`5439`: Point to the stable SymPy docs, not the dev docs
 * :ghpull:`5437`: Install jquery-ui images
 * :ghpull:`5434`: fix check for empty cells in rst template
 * :ghpull:`5432`: update links in notebook help menu
 * :ghpull:`5435`: Update whatsnew (notebook tour)
 * :ghpull:`5433`: Document extraction of octave and R magics
 * :ghpull:`5428`: Update COPYING.txt
 * :ghpull:`5426`: Separate get_session_info between HistoryAccessor and HistoryManager
 * :ghpull:`5419`: move prompts from margin to main column on small screens
 * :ghpull:`5430`: Make sure `element` is correct in the context of displayed JS
 * :ghpull:`5396`: prevent saving of partially loaded notebooks
 * :ghpull:`5429`: Fix tooltip pager feature
 * :ghpull:`5330`: Updates to shell reference doc
 * :ghpull:`5404`: Fix broken accordion widget
 * :ghpull:`5339`: Don't use fork to start the notebook in js tests
 * :ghpull:`5320`: Fix for Tooltip & completer click focus bug.
 * :ghpull:`5421`: Move configuration of Python test controllers into setup()
 * :ghpull:`5418`: fix typo in ssh launcher send_file
 * :ghpull:`5403`: remove alt-- shortcut
 * :ghpull:`5389`: better log message in deprecated files/ redirect
 * :ghpull:`5333`: Fix filenbmanager.list_dirs fails for Windows user profile directory
 * :ghpull:`5390`: finish PR #5333
 * :ghpull:`5326`: Some gardening on iptest result reporting
 * :ghpull:`5375`: remove unnecessary onload hack from mathjax macro
 * :ghpull:`5368`: Flexbox classes specificity fixes
 * :ghpull:`5331`: fix raw_input CSS
 * :ghpull:`5395`: urlencode images for rst files
 * :ghpull:`5049`: update quickhelp on adding and removing shortcuts
 * :ghpull:`5391`: Fix Gecko (Netscape) keyboard handling
 * :ghpull:`5387`: Respect '\r' characters in nbconvert.
 * :ghpull:`5399`: Revert PR #5388
 * :ghpull:`5388`: Suppress output even when a comment follows ;. Fixes #4525.
 * :ghpull:`5394`: nbconvert doc update
 * :ghpull:`5359`: do not install less sources
 * :ghpull:`5346`: give hint on where to find custom.js
 * :ghpull:`5357`: catch exception in copystat
 * :ghpull:`5380`: Remove DefineShortVerb... line from latex base template
 * :ghpull:`5376`: elide long containers in pretty
 * :ghpull:`5310`: remove raw cell placeholder on focus, closes #5238
 * :ghpull:`5332`: semantic names for indicator icons
 * :ghpull:`5386`: Fix import of socketserver on Python 3
 * :ghpull:`5360`: remove some redundant font-family: monospace
 * :ghpull:`5379`: don't instantiate Application just for default logger
 * :ghpull:`5372`: Don't autoclose strings
 * :ghpull:`5296`: unify keyboard shortcut and codemirror interaction
 * :ghpull:`5349`: Make Hub.registration_timeout configurable
 * :ghpull:`5340`: install bootstrap-tour css
 * :ghpull:`5335`: Update docstring for deepreload module
 * :ghpull:`5321`: Improve assignment regex to match more tuple unpacking syntax
 * :ghpull:`5325`: add NotebookNotary to NotebookApp's class list
 * :ghpull:`5313`: avoid loading preprocessors twice
 * :ghpull:`5308`: fix HTML capitalization in Highlight2HTML
 * :ghpull:`5295`: OutputArea.append_type functions are not prototype methods
 * :ghpull:`5318`: Fix local import of select_figure_formats
 * :ghpull:`5300`: Fix NameError: name '_rl' is not defined
 * :ghpull:`5292`: focus next cell on shift+enter
 * :ghpull:`5291`: debug occasional error in test_queue_status
 * :ghpull:`5289`: Finishing up #5274 (widget paths fixes)
 * :ghpull:`5232`: Make nbconvert html full output like notebook's html.
 * :ghpull:`5288`: Correct initial state of kernel status indicator
 * :ghpull:`5253`: display any output from this session in terminal console
 * :ghpull:`4802`: Tour of the notebook UI (was UI elements inline with highlighting)
 * :ghpull:`5285`: Update signature presentation in pinfo classes
 * :ghpull:`5268`: Refactoring Notebook.command_mode
 * :ghpull:`5226`: Don't run PYTHONSTARTUP file if a file or code is passed
 * :ghpull:`5283`: Remove Widget.closed attribute
 * :ghpull:`5279`: nbconvert: Make sure node is atleast version 0.9.12
 * :ghpull:`5281`: fix a typo introduced by a rebased PR
 * :ghpull:`5280`: append Firefox overflow-x fix
 * :ghpull:`5277`: check that PIL can save JPEG to BytesIO
 * :ghpull:`5044`: Store timestamps for modules to autoreload
 * :ghpull:`5278`: Update whatsnew doc from pr files
 * :ghpull:`5276`: Fix kernel restart in case connection file is deleted.
 * :ghpull:`5272`: allow highlighting language to be set from notebook metadata
 * :ghpull:`5158`: log refusal to serve hidden directories
 * :ghpull:`5188`: New events system
 * :ghpull:`5265`: Missing class def for TimeoutError
 * :ghpull:`5267`: normalize unicode in notebook API tests
 * :ghpull:`5076`: Refactor keyboard handling
 * :ghpull:`5241`: Add some tests for utils
 * :ghpull:`5261`: Don't allow edit mode up arrow to continue past index == 0
 * :ghpull:`5223`: use on-load event to trigger resizable images
 * :ghpull:`5252`: make one strptime call at import of jsonutil
 * :ghpull:`5153`: Dashboard sorting
 * :ghpull:`5169`: Allow custom header
 * :ghpull:`5242`: clear _reply_content cache before using it
 * :ghpull:`5194`: require latex titles to be ascii
 * :ghpull:`5244`: try to avoid EADDRINUSE errors on travis
 * :ghpull:`5245`: support extracted output in HTML template
 * :ghpull:`5209`: make input_area css generic to cells
 * :ghpull:`5246`: less %pylab, more cowbell!
 * :ghpull:`4895`: Improvements to %run completions
 * :ghpull:`5243`: Add Javscript to base display priority list.
 * :ghpull:`5175`: Audit .html() calls take #2
 * :ghpull:`5146`: Dual mode bug fixes.
 * :ghpull:`5207`: Children fire event
 * :ghpull:`5215`: Dashboard "Running" Tab
 * :ghpull:`5240`: Remove unused IPython.nbconvert.utils.console module
 * :ghpull:`5239`: Fix exclusion of tests directories from coverage reports
 * :ghpull:`5203`: capture some logging/warning output in some tests
 * :ghpull:`5216`: fixup positional arg handling in notebook app
 * :ghpull:`5229`: get _ipython_display_ method safely
 * :ghpull:`5234`: DOC : modified docs is HasTraits.traits and HasTraits.class_traits
 * :ghpull:`5221`: Change widget children List to Tuple.
 * :ghpull:`5231`: don't forget base_url when updating address bar in rename
 * :ghpull:`5173`: Moved widget files into static/widgets/*
 * :ghpull:`5222`: Unset PYTHONWARNINGS envvar before running subprocess tests.
 * :ghpull:`5172`: Prevent page breaks when printing notebooks via print-view.
 * :ghpull:`4985`: Add automatic Closebrackets function to Codemirror.
 * :ghpull:`5220`: Make traitlets notify check more robust against classes redefining equality and bool
 * :ghpull:`5197`: If there is an error comparing traitlet values when setting a trait, default to go ahead and notify of the new value.
 * :ghpull:`5210`: fix pyreadline import in rlineimpl
 * :ghpull:`5212`: Wrap nbconvert Markdown/Heading cells in live divs
 * :ghpull:`5200`: Allow to pass option to jinja env
 * :ghpull:`5202`: handle nodejs executable on debian
 * :ghpull:`5112`: band-aid for completion
 * :ghpull:`5187`: handle missing output metadata in nbconvert
 * :ghpull:`5181`: use gnureadline on OS X
 * :ghpull:`5136`: set default value from signature defaults in interact
 * :ghpull:`5132`: remove application/pdf->pdf transform in javascript
 * :ghpull:`5116`: reorganize who knows what about paths
 * :ghpull:`5165`: Don't introspect __call__ for simple callables
 * :ghpull:`5170`: Added msg_throttle sync=True widget traitlet
 * :ghpull:`5191`: Translate markdown link to rst
 * :ghpull:`5037`: FF Fix: alignment and scale of text widget
 * :ghpull:`5179`: remove websocket url
 * :ghpull:`5110`: add InlineBackend.print_figure_kwargs
 * :ghpull:`5147`: Some template URL changes
 * :ghpull:`5100`: remove base_kernel_url
 * :ghpull:`5163`: Simplify implementation of TemporaryWorkingDirectory.
 * :ghpull:`5166`: remove mktemp usage
 * :ghpull:`5133`: don't use combine option on ucs package
 * :ghpull:`5089`: Remove legacy azure nbmanager
 * :ghpull:`5159`: remove append_json reference
 * :ghpull:`5095`: handle image size metadata in nbconvert html
 * :ghpull:`5156`: fix IPython typo, closes #5155
 * :ghpull:`5150`: fix a link that was broken
 * :ghpull:`5114`: use non-breaking space for button with no description
 * :ghpull:`4778`: add APIs for installing notebook extensions
 * :ghpull:`5125`: Fix the display of functions with keyword-only arguments on Python 3.
 * :ghpull:`5097`: minor notebook logging changes
 * :ghpull:`5047`: only validate package_data when it might be used
 * :ghpull:`5121`: fix remove event in KeyboardManager.register_events
 * :ghpull:`5119`: Removed 'list' view from Variable Inspector example
 * :ghpull:`4925`: Notebook manager api fixes
 * :ghpull:`4996`: require print_method to be a bound method
 * :ghpull:`5108`: require specifying the version for gh-pages
 * :ghpull:`5111`: Minor typo in docstring of IPython.parallel DirectView
 * :ghpull:`5098`: mostly debugging changes for IPython.parallel
 * :ghpull:`5087`: trust cells with no output
 * :ghpull:`5059`: Fix incorrect `Patch` logic in widget code
 * :ghpull:`5075`: More flexible box model fixes
 * :ghpull:`5091`: Provide logging messages in ipcluster log when engine or controllers fail to start
 * :ghpull:`5090`: Print a warning when iptest is run from the IPython source directory
 * :ghpull:`5077`: flush replies when entering an eventloop
 * :ghpull:`5055`: Minimal changes to import IPython from IronPython
 * :ghpull:`5078`: Updating JS tests README.md
 * :ghpull:`5083`: don't create js test directories unless they are being used
 * :ghpull:`5062`: adjust some events in nb_roundtrip
 * :ghpull:`5043`: various unicode / url fixes
 * :ghpull:`5066`: remove (almost) all mentions of pylab from our examples
 * :ghpull:`4977`: ensure scp destination directories exist (with mkdir -p)
 * :ghpull:`5053`: Move&rename JS tests
 * :ghpull:`5067`: show traceback in widget handlers
 * :ghpull:`4920`: Adding PDFFormatter and kernel side handling of PDF display data
 * :ghpull:`5048`: Add edit/command mode indicator
 * :ghpull:`5061`: make execute button in menu bar match shift-enter
 * :ghpull:`5052`: Add q to toggle the pager.
 * :ghpull:`5070`: fix flex: auto
 * :ghpull:`5065`: Add example of using annotations in interact
 * :ghpull:`5063`: another pass on Interact example notebooks
 * :ghpull:`5051`: FF Fix: code cell missing hscroll (2)
 * :ghpull:`4960`: Interact/Interactive for widget
 * :ghpull:`5045`: Clear timeout in multi-press keyboard shortcuts.
 * :ghpull:`5060`: Change 'bind' to 'link'
 * :ghpull:`5039`: Expose kernel_info method on inprocess kernel client
 * :ghpull:`5058`: Fix iopubwatcher.py example script.
 * :ghpull:`5035`: FF Fix: code cell missing hscroll
 * :ghpull:`5040`: Polishing some docs
 * :ghpull:`5001`: Add directory navigation to dashboard
 * :ghpull:`5042`: Remove duplicated Channel ABC classes.
 * :ghpull:`5036`: FF Fix: ext link icon same line as link text in help menu
 * :ghpull:`4975`: setup.py changes for 2.0
 * :ghpull:`4774`: emit event on appended element on dom
 * :ghpull:`5023`: Widgets- add ability to pack and unpack arrays on JS side.
 * :ghpull:`5003`: Fix pretty reprs of super() objects
 * :ghpull:`4974`: make paste focus the pasted cell
 * :ghpull:`5012`: Make `SelectionWidget.values` a dict
 * :ghpull:`5018`: Prevent 'iptest IPython' from trying to run.
 * :ghpull:`5025`: citation2latex filter (using HTMLParser)
 * :ghpull:`5027`: pin lessc to 1.4
 * :ghpull:`4952`: Widget test inconsistencies
 * :ghpull:`5014`: Fix command mode & popup view bug
 * :ghpull:`4842`: more subtle kernel indicator
 * :ghpull:`5017`: Add notebook examples link to help menu.
 * :ghpull:`5015`: don't write cell.trusted to disk
 * :ghpull:`5007`: Update whatsnew doc from PR files
 * :ghpull:`5010`: Fixes for widget alignment in FF
 * :ghpull:`4901`: Add a convenience class to sync traitlet attributes
 * :ghpull:`5008`: updated explanation of 'pyin' messages
 * :ghpull:`5004`: Fix widget vslider spacing
 * :ghpull:`4933`: Small Widget inconsistency fixes
 * :ghpull:`4979`: add versioning notes to small message spec changes
 * :ghpull:`4893`: add font-awesome 3.2.1
 * :ghpull:`4982`: Live readout for slider widgets
 * :ghpull:`4813`: make help menu a template
 * :ghpull:`4939`: Embed qtconsole docs (continued)
 * :ghpull:`4964`: remove shift-= merge keyboard shortcut
 * :ghpull:`4504`: Allow input transformers to raise SyntaxError
 * :ghpull:`4929`: Fixing various modal/focus related bugs
 * :ghpull:`4971`: Fixing issues with js tests
 * :ghpull:`4972`: Work around problem in doctest discovery in Python 3.4 with PyQt
 * :ghpull:`4937`: pickle arrays with dtype=object
 * :ghpull:`4934`: `ipython profile create` respects `--ipython-dir`
 * :ghpull:`4954`: generate unicode filename
 * :ghpull:`4845`: Add Origin Checking.
 * :ghpull:`4916`: Fine tuning the behavior of the modal UI
 * :ghpull:`4966`: Ignore sys.argv for NotebookNotary in tests
 * :ghpull:`4967`: Fix typo in warning about web socket being closed
 * :ghpull:`4965`: Remove mention of iplogger from setup.py
 * :ghpull:`4962`: Fixed typos in quick-help text
 * :ghpull:`4953`: add utils.wait_for_idle in js tests
 * :ghpull:`4870`: ipython_directive, report except/warn in block and add :okexcept: :okwarning: options to suppress
 * :ghpull:`4662`: Menu cleanup
 * :ghpull:`4824`: sign notebooks
 * :ghpull:`4943`: Docs shotgun 4
 * :ghpull:`4848`: avoid import of nearby temporary with %edit
 * :ghpull:`4950`: Two fixes for file upload related bugs
 * :ghpull:`4927`: there shouldn't be a 'files/' prefix in FileLink[s]
 * :ghpull:`4928`: use importlib.machinery when available
 * :ghpull:`4949`: Remove the docscrape modules, which are part of numpydoc
 * :ghpull:`4849`: Various unicode fixes (mostly on Windows)
 * :ghpull:`4932`: always point py3compat.input to builtin_mod.input
 * :ghpull:`4807`: Correct handling of ansi colour codes when nbconverting to latex
 * :ghpull:`4922`: Python nbconvert output shouldn't have output
 * :ghpull:`4912`: Skip some Windows io failures
 * :ghpull:`4919`: flush output before showing tracebacks
 * :ghpull:`4915`: ZMQCompleter inherits from IPCompleter
 * :ghpull:`4890`: better cleanup channel FDs
 * :ghpull:`4880`: set profile name from profile_dir
 * :ghpull:`4853`: fix setting image height/width from metadata
 * :ghpull:`4786`: Reduce spacing of heading cells
 * :ghpull:`4680`: Minimal pandoc version warning
 * :ghpull:`4908`: detect builtin docstrings in oinspect
 * :ghpull:`4911`: Don't use `python -m package` on Windows Python 2
 * :ghpull:`4909`: sort dictionary keys before comparison, ordering is not guaranteed
 * :ghpull:`4374`: IPEP 23: Backbone.js Widgets
 * :ghpull:`4903`: use https for all embeds
 * :ghpull:`4894`: Shortcut changes
 * :ghpull:`4897`: More detailed documentation about kernel_cmd
 * :ghpull:`4891`: Squash a few Sphinx warnings from nbconvert.utils.lexers docstrings
 * :ghpull:`4679`: JPG compression for inline pylab
 * :ghpull:`4708`: Fix indent and center
 * :ghpull:`4789`: fix IPython.embed
 * :ghpull:`4655`: prefer marked to pandoc for markdown2html
 * :ghpull:`4876`: don't show tooltip if object is not found
 * :ghpull:`4873`: use 'combine' option to ucs package
 * :ghpull:`4732`: Accents in notebook names and in command-line (nbconvert)
 * :ghpull:`4867`: Update URL for Lawrence Hall of Science webcam image
 * :ghpull:`4868`: Static path fixes
 * :ghpull:`4858`: fix tb_offset when running a file
 * :ghpull:`4826`: some $.html( -> $.text(
 * :ghpull:`4847`: add js kernel_info request
 * :ghpull:`4832`: allow NotImplementedError in formatters
 * :ghpull:`4803`: BUG: fix cython magic support in ipython_directive
 * :ghpull:`4865`: `build` listed twice in .gitignore. Removing one.
 * :ghpull:`4851`: fix tooltip token regex for single-character names
 * :ghpull:`4846`: Remove some leftover traces of irunner
 * :ghpull:`4820`: fix regex for cleaning old logs with ipcluster
 * :ghpull:`4844`: adjustments to notebook app logging
 * :ghpull:`4840`: Error in Session.send_raw()
 * :ghpull:`4819`: update CodeMirror to 3.21
 * :ghpull:`4823`: Minor fixes for typos/inconsistencies in parallel docs
 * :ghpull:`4811`: document code mirror tab and shift-tab
 * :ghpull:`4795`: merge reveal templates
 * :ghpull:`4796`: update components
 * :ghpull:`4806`: Correct order of packages for unicode in nbconvert to LaTeX
 * :ghpull:`4800`: Qt frontend: Handle 'aborted' prompt replies.
 * :ghpull:`4794`: Compatibility fix for Python3 (Issue #4783 )
 * :ghpull:`4799`: minor js test fix
 * :ghpull:`4788`: warn when notebook is started in pylab mode
 * :ghpull:`4772`: Notebook server info files
 * :ghpull:`4797`: be conservative about kernel_info implementation
 * :ghpull:`4787`: non-python kernels run python code with qtconsole
 * :ghpull:`4565`: various display type validations
 * :ghpull:`4703`: Math macro in jinja templates.
 * :ghpull:`4781`: Fix "Source" text for the "Other Syntax" section of the "Typesetting Math" notebook
 * :ghpull:`4776`: Manually document py3compat module.
 * :ghpull:`4533`: propagate display metadata to all mimetypes
 * :ghpull:`4785`: Replacing a for-in loop by an index loop on an array
 * :ghpull:`4780`: Updating CSS for UI example.
 * :ghpull:`3605`: Modal UI
 * :ghpull:`4758`: Python 3.4 fixes
 * :ghpull:`4735`: add some HTML error pages
 * :ghpull:`4775`: Update whatsnew doc from PR files
 * :ghpull:`4760`: Make examples and docs more Python 3 aware
 * :ghpull:`4773`: Don't wait forever for notebook server to launch/die for tests
 * :ghpull:`4768`: Qt console: Fix _prompt_pos accounting on timer flush output.
 * :ghpull:`4727`: Remove Nbconvert template loading magic
 * :ghpull:`4763`: Set numpydoc options to produce fewer Sphinx warnings.
 * :ghpull:`4770`: always define aliases, even if empty
 * :ghpull:`4766`: add `python -m` entry points for everything
 * :ghpull:`4767`: remove manpages for irunner, iplogger
 * :ghpull:`4751`: Added --post-serve explanation into the nbconvert docs.
 * :ghpull:`4762`: whitelist alphanumeric characters for cookie_name
 * :ghpull:`4625`: Deprecate %profile magic
 * :ghpull:`4745`: warn on failed formatter calls
 * :ghpull:`4746`: remove redundant cls alias on Windows
 * :ghpull:`4749`: Fix bug in determination of public ips.
 * :ghpull:`4715`: restore use of tornado static_url in templates
 * :ghpull:`4748`: fix race condition in profiledir creation.
 * :ghpull:`4720`: never use ssh multiplexer in tunnels
 * :ghpull:`4658`: Bug fix for #4643: Regex object needs to be reset between calls in toolt...
 * :ghpull:`4561`: Add Formatter.pop(type)
 * :ghpull:`4712`: Docs shotgun 3
 * :ghpull:`4713`: Fix saving kernel history in Python 2
 * :ghpull:`4744`: don't use lazily-evaluated rc.ids in wait_for_idle
 * :ghpull:`4740`: %env can't set variables
 * :ghpull:`4737`: check every link when detecting virutalenv
 * :ghpull:`4738`: don't inject help into user_ns
 * :ghpull:`4739`: skip html nbconvert tests when their dependencies are missing
 * :ghpull:`4730`: Fix stripping continuation prompts when copying from Qt console
 * :ghpull:`4725`: Doc fixes
 * :ghpull:`4656`: Nbconvert HTTP service
 * :ghpull:`4710`: make @interactive decorator friendlier with dill
 * :ghpull:`4722`: allow purging local results as long as they are not outstanding
 * :ghpull:`4549`: Updated IPython console lexers.
 * :ghpull:`4570`: Update IPython directive
 * :ghpull:`4719`: Fix comment typo in prefilter.py
 * :ghpull:`4575`: make sure to encode URL components for API requests
 * :ghpull:`4718`: Fixed typo in displaypub
 * :ghpull:`4716`: Remove input_prefilter hook
 * :ghpull:`4691`: survive failure to bind to localhost in zmq.iostream
 * :ghpull:`4696`: don't do anything if add_anchor fails
 * :ghpull:`4711`: some typos in the docs
 * :ghpull:`4700`: use if main block in entry points
 * :ghpull:`4692`: setup.py symlink improvements
 * :ghpull:`4265`: JSON configuration file
 * :ghpull:`4505`: Nbconvert latex markdown images2
 * :ghpull:`4608`: transparent background match ... all colors
 * :ghpull:`4678`: allow ipython console to handle text/plain display
 * :ghpull:`4706`: remove irunner, iplogger
 * :ghpull:`4701`: Delete an old dictionary available for selecting the aligment of text.
 * :ghpull:`4702`: Making reveal font-size a relative unit.
 * :ghpull:`4649`: added a quiet option to %cpaste to suppress output
 * :ghpull:`4690`: Option to spew subprocess streams during tests
 * :ghpull:`4688`: Fixed various typos in docstrings.
 * :ghpull:`4645`: CasperJs utility functions.
 * :ghpull:`4670`: Stop bundling the numpydoc Sphinx extension
 * :ghpull:`4675`: common IPython prefix for ModIndex
 * :ghpull:`4672`: Remove unused 'attic' module
 * :ghpull:`4671`: Fix docstrings in utils.text
 * :ghpull:`4669`: add missing help strings to HistoryManager configurables
 * :ghpull:`4668`: Make non-ASCII docstring unicode
 * :ghpull:`4650`: added a note about sharing of nbconvert tempates
 * :ghpull:`4646`: Fixing various output related things:
 * :ghpull:`4665`: check for libedit in readline on OS X
 * :ghpull:`4606`: Make running PYTHONSTARTUP optional
 * :ghpull:`4654`: Fixing left padding of text cells to match that of code cells.
 * :ghpull:`4306`: add raw_mimetype metadata to raw cells
 * :ghpull:`4576`: Tighten up the vertical spacing on cells and make the padding of cells more consistent
 * :ghpull:`4353`: Don't reset the readline completer after each prompt
 * :ghpull:`4567`: Adding prompt area to non-CodeCells to indent content.
 * :ghpull:`4446`: Use SVG plots in OctaveMagic by default due to lack of Ghostscript on Windows Octave
 * :ghpull:`4613`: remove configurable.created
 * :ghpull:`4631`: Use argument lists for command help tests
 * :ghpull:`4633`: Modifies test_get_long_path_name_winr32() to allow for long path names in temp dir
 * :ghpull:`4642`: Allow docs to build without PyQt installed.
 * :ghpull:`4641`: Don't check for wx in the test suite.
 * :ghpull:`4622`: make QtConsole Lexer configurable
 * :ghpull:`4594`: Fixed #2923 Move Save Away from Cut in toolbar
 * :ghpull:`4593`: don't interfere with set_next_input contents in qtconsole
 * :ghpull:`4640`: Support matplotlib's Gtk3 backend in --pylab mode
 * :ghpull:`4639`: Minor import fix to get qtconsole with --pylab=qt working
 * :ghpull:`4637`: Fixed typo in links.txt.
 * :ghpull:`4634`: Fix nbrun in notebooks with non-code cells.
 * :ghpull:`4632`: Restore the ability to run tests from a function.
 * :ghpull:`4624`: Fix crash when $EDITOR is non-ASCII
 * :ghpull:`4453`: Play nice with App Nap
 * :ghpull:`4541`: relax ipconfig matching on Windows
 * :ghpull:`4552`: add pickleutil.use_dill
 * :ghpull:`4590`: Font awesome for IPython slides
 * :ghpull:`4589`: Inherit the width of pre code inside the input code cells.
 * :ghpull:`4588`: Update reveal.js CDN to 2.5.0.
 * :ghpull:`4569`: store cell toolbar preset in notebook metadata
 * :ghpull:`4609`: Fix bytes regex for Python 3.
 * :ghpull:`4581`: Writing unicode to stdout
 * :ghpull:`4591`: Documenting codemirror shorcuts.
 * :ghpull:`4607`: Tutorial doc should link to user config intro
 * :ghpull:`4601`: test that rename fails with 409 if it would clobber
 * :ghpull:`4599`: re-cast int/float subclasses to int/float in json_clean
 * :ghpull:`4542`: new `ipython history clear` subcommand
 * :ghpull:`4568`: don't use lazily-evaluated rc.ids in wait_for_idle
 * :ghpull:`4572`: DOC: %profile docstring should reference %prun
 * :ghpull:`4571`: no longer need 3 suffix on travis, tox
 * :ghpull:`4566`: Fixing cell_type in CodeCell constructor.
 * :ghpull:`4563`: Specify encoding for reading notebook file.
 * :ghpull:`4452`: support notebooks in %run
 * :ghpull:`4546`: fix warning condition on notebook startup
 * :ghpull:`4540`: Apidocs3
 * :ghpull:`4553`: Fix Python 3 handling of urllib
 * :ghpull:`4543`: make hiding of initial namespace optional
 * :ghpull:`4517`: send shutdown_request on exit of `ipython console`
 * :ghpull:`4528`: improvements to bash completion
 * :ghpull:`4532`: Hide dynamically defined metaclass base from Sphinx.
 * :ghpull:`4515`: Spring Cleaning, and  Load speedup
 * :ghpull:`4529`: note routing identities needed for input requests
 * :ghpull:`4514`: allow restart in `%run -d`
 * :ghpull:`4527`: add redirect for 1.0-style 'files/' prefix links
 * :ghpull:`4526`: Allow unicode arguments to passwd_check on Python 2
 * :ghpull:`4403`: Global highlight language selection.
 * :ghpull:`4250`: outputarea.js: Wrap inline SVGs inside an iframe
 * :ghpull:`4521`: Read wav files in binary mode
 * :ghpull:`4444`: Css cleaning
 * :ghpull:`4523`: Use username and password for MongoDB on ShiningPanda
 * :ghpull:`4510`: Update whatsnew from PR files
-* :ghpull:`4441`: add `setup.py jsversion`
+* :ghpull:`4441`: add ``setup.py jsversion``
 * :ghpull:`4518`: Fix for race condition in url file decoding.
 * :ghpull:`4497`: don't automatically unpack datetime objects in the message spec
 * :ghpull:`4506`: wait for empty queues as well as load-balanced tasks
 * :ghpull:`4492`: Configuration docs refresh
 * :ghpull:`4508`: Fix some uses of map() in Qt console completion code.
 * :ghpull:`4498`: Daemon StreamCapturer
 * :ghpull:`4499`: Skip clipboard test on unix systems if headless.
 * :ghpull:`4460`: Better clipboard handling, esp. with pywin32
 * :ghpull:`4496`: Pass nbformat object to write call to save .py script
 * :ghpull:`4466`: various pandoc latex fixes
 * :ghpull:`4473`: Setup for Python 2/3
 * :ghpull:`4459`: protect against broken repr in lib.pretty
 * :ghpull:`4457`: Use ~/.ipython as default config directory
 * :ghpull:`4489`: check realpath of env in init_virtualenv
 * :ghpull:`4490`: fix possible race condition in test_await_data
 * :ghpull:`4476`: Fix: Remove space added by display(JavaScript) on page reload
 * :ghpull:`4398`: [Notebook] Deactivate tooltip on tab by default.
 * :ghpull:`4480`: Docs shotgun 2
 * :ghpull:`4488`: fix typo in message spec doc
 * :ghpull:`4479`: yet another JS race condition fix
 * :ghpull:`4477`: Allow incremental builds of the html_noapi docs target
 * :ghpull:`4470`: Various Config object cleanups
 * :ghpull:`4410`: make close-and-halt work on new tabs in Chrome
 * :ghpull:`4469`: Python 3 & getcwdu
 * :ghpull:`4451`: fix: allow JS test to run after shutdown test
 * :ghpull:`4456`: Simplify StreamCapturer for subprocess testing
 * :ghpull:`4464`: Correct description for Bytes traitlet type
 * :ghpull:`4465`: Clean up MANIFEST.in
 * :ghpull:`4461`: Correct TypeError message in svg2pdf
 * :ghpull:`4458`: use signalstatus if exit status is undefined
 * :ghpull:`4438`: Single codebase Python 3 support (again)
 * :ghpull:`4198`: Version conversion, support for X to Y even if Y < X (nbformat)
 * :ghpull:`4415`: More tooltips in the Notebook menu
 * :ghpull:`4450`: remove monkey patch for older versions of tornado
 * :ghpull:`4423`: Fix progress bar and scrolling bug.
 * :ghpull:`4435`: raise 404 on not found static file
 * :ghpull:`4442`: fix and add shim for change introduce by #4195
 * :ghpull:`4436`: allow `require("nbextensions/extname")` to load from IPYTHONDIR/nbextensions
 * :ghpull:`4437`: don't compute etags in static file handlers
 * :ghpull:`4427`: notebooks should always have one checkpoint
 * :ghpull:`4425`: fix js pythonisme
 * :ghpull:`4195`: IPEP 21:  widget messages
 * :ghpull:`4434`: Fix broken link for Dive Into Python.
 * :ghpull:`4428`: bump minimum tornado version to 3.1.0
 * :ghpull:`4302`: Add an Audio display class
 * :ghpull:`4285`: Notebook javascript test suite using CasperJS
 * :ghpull:`4420`: Allow checking for backports via milestone
 * :ghpull:`4426`: set kernel cwd to notebook's directory
 * :ghpull:`4389`: By default, Magics inherit from Configurable
 * :ghpull:`4393`: Capture output from subprocs during test, and display on failure
 * :ghpull:`4419`: define InlineBackend configurable in its own file
 * :ghpull:`4303`: Multidirectory support for the Notebook
 * :ghpull:`4371`: Restored ipython profile locate dir and fixed typo. (Fixes #3708).
 * :ghpull:`4414`: Specify unicode type properly in rmagic
 * :ghpull:`4413`: don't instantiate IPython shell as class attr
 * :ghpull:`4400`: Remove 5s wait on inactivity on GUI inputhook loops
 * :ghpull:`4412`: Fix traitlet _notify_trait by-ref issue
 * :ghpull:`4378`: split adds new cell above, rather than below
 * :ghpull:`4405`: Bring display of builtin types and functions in line with Py 2
 * :ghpull:`4367`: clean up of documentation files
 * :ghpull:`4401`: Provide a name of the HistorySavingThread
 * :ghpull:`4384`: fix menubar height measurement
 * :ghpull:`4377`: fix tooltip cancel
 * :ghpull:`4293`: Factorise code in tooltip for julia monkeypatching
 * :ghpull:`4292`: improve js-completer logic.
 * :ghpull:`4363`: set_next_input: keep only last input when repeatedly called in a single cell
 * :ghpull:`4382`: Use safe_hasattr in dir2
 * :ghpull:`4379`: fix (CTRL-M -) shortcut for splitting cell in FF
 * :ghpull:`4380`: Test and fixes for localinterfaces
 * :ghpull:`4372`: Don't assume that SyntaxTB is always called with a SyntaxError
 * :ghpull:`4342`: Return value directly from the try block and avoid a variable
 * :ghpull:`4154`: Center LaTeX and figures in markdown
 * :ghpull:`4311`: %load -s to load specific functions or classes
 * :ghpull:`4350`: WinHPC launcher fixes
 * :ghpull:`4345`: Make irunner compatible with upcoming pexpect 3.0 interface
 * :ghpull:`4276`: Support container methods in config
 * :ghpull:`4359`: test_pylabtools also needs to modify matplotlib.rcParamsOrig
 * :ghpull:`4355`: remove hardcoded box-orient
 * :ghpull:`4333`: Add Edit Notebook Metadata to Edit menu
 * :ghpull:`4349`: Script to update What's New file
 * :ghpull:`4348`: Call PDF viewer after latex compiling (nbconvert)
 * :ghpull:`4346`: getpass() on Windows & Python 2 needs bytes prompt
 * :ghpull:`4304`: use netifaces for faster IPython.utils.localinterfaces
 * :ghpull:`4305`: Add even more ways to populate localinterfaces
 * :ghpull:`4313`: remove strip_math_space
 * :ghpull:`4325`: Some changes to improve readability.
 * :ghpull:`4281`: Adjust tab completion widget if too close to bottom of page.
 * :ghpull:`4347`: Remove pycolor script
 * :ghpull:`4322`: Scroll to the top after change of slides in the IPython slides
 * :ghpull:`4289`: Fix scrolling output (not working post clear_output changes)
 * :ghpull:`4343`: Make parameters for kernel start method more general
 * :ghpull:`4237`: Keywords should shadow magic functions
 * :ghpull:`4338`: adjust default value of level in sync_imports
 * :ghpull:`4328`: Remove unused loop variable.
 * :ghpull:`4340`: fix mathjax download url to new GitHub format
 * :ghpull:`4336`: use simple replacement rather than string formatting in format_kernel_cmd
 * :ghpull:`4264`: catch unicode error listing profiles
 * :ghpull:`4314`: catch EACCES when binding notebook app
 * :ghpull:`4324`: Remove commented addthis toolbar
 * :ghpull:`4327`: Use the with statement to open a file.
 * :ghpull:`4318`: fix initial sys.path
 * :ghpull:`4315`: Explicitly state what version of Pandoc is supported in docs/install
 * :ghpull:`4316`: underscore missing on notebook_p4
 * :ghpull:`4295`: Implement boundary option for load magic (#1093) 
 * :ghpull:`4300`: traits defauts are strings not object
 * :ghpull:`4297`: Remove an unreachable return statement.
 * :ghpull:`4260`: Use subprocess for system_raw
 * :ghpull:`4277`: add nbextensions
 * :ghpull:`4294`: don't require tornado 3 in `--post serve`
 * :ghpull:`4270`: adjust Scheduler timeout logic
 * :ghpull:`4278`: add `-a` to easy_install command in libedit warning
 * :ghpull:`4282`: Enable automatic line breaks in MathJax.
 * :ghpull:`4279`: Fixing line-height of list items in tree view.
 * :ghpull:`4253`: fixes #4039.
 * :ghpull:`4131`: Add module's name argument in %%cython magic
 * :ghpull:`4269`: Add mathletters option and longtable package to latex_base.tplx
 * :ghpull:`4230`: Switch correctly to the user's default matplotlib backend after inline.
 * :ghpull:`4271`: Hopefully fix ordering of output on ShiningPanda
 * :ghpull:`4239`: more informative error message for bad serialization
 * :ghpull:`4263`: Fix excludes for IPython.testing
 * :ghpull:`4112`: nbconvert: Latex template refactor
 * :ghpull:`4261`: Fixing a formatting error in the custom display example notebook.
 * :ghpull:`4259`: Fix Windows test exclusions
 * :ghpull:`4229`: Clear_output: Animation & widget related changes.
 * :ghpull:`4151`: Refactor alias machinery
 * :ghpull:`4153`: make timeit return an object that contains values
 * :ghpull:`4258`: to-backport label is now 1.2
 * :ghpull:`4242`: Allow passing extra arguments to iptest through for nose
 * :ghpull:`4257`: fix unicode argv parsing
 * :ghpull:`4166`: avoid executing code in utils.localinterfaces at import time
 * :ghpull:`4214`: engine ID metadata should be unicode, not bytes
 * :ghpull:`4232`: no highlight if no language specified
 * :ghpull:`4218`: Fix display of SyntaxError when .py file is modified
-* :ghpull:`4207`: add `setup.py css` command
+* :ghpull:`4207`: add ``setup.py css`` command
 * :ghpull:`4224`: clear previous callbacks on execute
 * :ghpull:`4180`: Iptest refactoring
 * :ghpull:`4105`: JS output area misaligned
 * :ghpull:`4220`: Various improvements to docs formatting
 * :ghpull:`4187`: Select adequate highlighter for cell magic languages
 * :ghpull:`4228`: update -dev docs to reflect latest stable version
 * :ghpull:`4219`: Drop bundled argparse
 * :ghpull:`3851`: Adds an explicit newline for pretty-printing.
 * :ghpull:`3622`: Drop fakemodule
 * :ghpull:`4080`: change default behavior of database task storage
 * :ghpull:`4197`: enable cython highlight in notebook
 * :ghpull:`4225`: Updated docstring for core.display.Image
 * :ghpull:`4175`: nbconvert: Jinjaless exporter base
 * :ghpull:`4208`: Added a lightweight "htmlcore" Makefile entry
 * :ghpull:`4209`: Magic doc fixes
 * :ghpull:`4217`: avoid importing numpy at the module level
 * :ghpull:`4213`: fixed dead link in examples/notebooks readme to Part 3
 * :ghpull:`4183`: ESC should be handled by CM if tooltip is not on
 * :ghpull:`4193`: Update for #3549: Append Firefox overflow-x fix
 * :ghpull:`4205`: use TextIOWrapper when communicating with pandoc subprocess
 * :ghpull:`4204`: remove some extraneous print statements from IPython.parallel
 * :ghpull:`4201`: HeadingCells cannot be split or merged
 * :ghpull:`4048`: finish up speaker-notes PR
 * :ghpull:`4079`: trigger `Kernel.status_started` after websockets open
 * :ghpull:`4186`: moved DummyMod to proper namespace to enable dill pickling
 * :ghpull:`4190`: update version-check message in setup.py and IPython.__init__
 * :ghpull:`4188`: Allow user_ns trait to be None
 * :ghpull:`4189`: always fire LOCAL_IPS.extend(PUBLIC_IPS)
 * :ghpull:`4174`: various issues in markdown and rst templates
 * :ghpull:`4178`: add missing data_javascript
 * :ghpull:`4168`: Py3 failing tests
 * :ghpull:`4181`: nbconvert: Fix, sphinx template not removing new lines from headers
 * :ghpull:`4043`: don't 'restore_bytes' in from_JSON
 * :ghpull:`4149`: reuse more kernels in kernel tests
 * :ghpull:`4163`: Fix for incorrect default encoding on Windows.
 * :ghpull:`4136`: catch javascript errors in any output
 * :ghpull:`4171`: add nbconvert config file when creating profiles
 * :ghpull:`4172`: add ability to check what PRs should be backported in backport_pr
 * :ghpull:`4167`: --fast flag for test suite!
 * :ghpull:`4125`: Basic exercise of `ipython [subcommand] -h` and help-all
 * :ghpull:`4085`: nbconvert: Fix sphinx preprocessor date format string for Windows
 * :ghpull:`4159`: don't split `.cell` and `div.cell` CSS
 * :ghpull:`4165`: Remove use of parametric tests
 * :ghpull:`4158`: generate choices for `--gui` configurable from real mapping
 * :ghpull:`4083`: Implement a better check for hidden values for %who etc.
 * :ghpull:`4147`: Reference notebook examples, fixes #4146.
 * :ghpull:`4065`: do not include specific css in embedable one
 * :ghpull:`4092`: nbconvert: Fix for unicode html headers, Windows + Python 2.x
 * :ghpull:`4074`: close Client sockets if connection fails
 * :ghpull:`4064`: Store default codemirror mode in only 1 place
 * :ghpull:`4104`: Add way to install MathJax to a particular profile
 * :ghpull:`4161`: Select name when renaming a notebook
 * :ghpull:`4160`: Add quotes around ".[notebook]" in readme
 * :ghpull:`4144`: help_end transformer shouldn't pick up ? in multiline string
 * :ghpull:`4090`: Add LaTeX citation handling to nbconvert
 * :ghpull:`4143`: update example custom.js
 * :ghpull:`4142`: DOC: unwrap openssl line in public_server doc
 * :ghpull:`4126`: update tox.ini
 * :ghpull:`4141`: add files with a separate `add` call in backport_pr
 * :ghpull:`4137`: Restore autorestore option for storemagic
 * :ghpull:`4098`: pass profile-dir instead of profile name to Kernel
 * :ghpull:`4120`: support `input` in Python 2 kernels
 * :ghpull:`4088`: nbconvert: Fix coalescestreams line with incorrect nesting causing strange behavior
 * :ghpull:`4060`: only strip continuation prompts if regular prompts seen first
 * :ghpull:`4132`: Fixed name error bug in function safe_unicode in module py3compat.
 * :ghpull:`4121`: move test_kernel from IPython.zmq to IPython.kernel
 * :ghpull:`4118`: ZMQ heartbeat channel: catch EINTR exceptions and continue.
 * :ghpull:`4070`: New changes should go into pr/ folder
 * :ghpull:`4054`: use unicode for HTML export
 * :ghpull:`4106`: fix a couple of default block values
 * :ghpull:`4107`: update parallel magic tests with capture_output API
 * :ghpull:`4102`: Fix clashes between debugger tests and coverage.py
 * :ghpull:`4115`: Update docs on declaring a magic function
 * :ghpull:`4101`: restore accidentally removed EngineError
 * :ghpull:`4096`: minor docs changes
 * :ghpull:`4094`: Update target branch before backporting PR
 * :ghpull:`4069`: Drop monkeypatch for pre-1.0 nose
 * :ghpull:`4056`: respect `pylab_import_all` when `--pylab` specified at the command-line
 * :ghpull:`4091`: Make Qt console banner configurable
 * :ghpull:`4086`: fix missing errno import
 * :ghpull:`4084`: Use msvcrt.getwch() for Windows pager.
 * :ghpull:`4073`: rename ``post_processors`` submodule to ``postprocessors``
 * :ghpull:`4075`: Update supported Python versions in tools/test_pr
 * :ghpull:`4068`: minor bug fix, define 'cell' in dialog.js.
 * :ghpull:`4044`: rename call methods to transform and postprocess
 * :ghpull:`3744`: capture rich output as well as stdout/err in capture_output
 * :ghpull:`3969`: "use strict" in most (if not all) our javascript
 * :ghpull:`4030`: exclude `.git` in MANIFEST.in
 * :ghpull:`4047`: Use istype() when checking if canned object is a dict
 * :ghpull:`4031`: don't close_fds on Windows
 * :ghpull:`4029`: bson.Binary moved
 * :ghpull:`3883`: skip test on unix when x11 not available
 * :ghpull:`3863`: Added working speaker notes for slides.
 * :ghpull:`4035`: Fixed custom jinja2 templates being ignored when setting template_path
 * :ghpull:`4002`: Drop Python 2.6 and 3.2
 * :ghpull:`4026`: small doc fix in nbconvert
 * :ghpull:`4016`: Fix IPython.start_* functions
 * :ghpull:`4021`: Fix parallel.client.View map() on numpy arrays
 * :ghpull:`4022`: DOC: fix links to matplotlib, notebook docs
 * :ghpull:`4018`: Fix warning when running IPython.kernel tests
 * :ghpull:`4017`: Add REPL-like printing of final/return value to %%R cell magic
 * :ghpull:`4019`: Test skipping without unicode paths
 * :ghpull:`4008`: Transform code before %prun/%%prun runs
 * :ghpull:`4014`: Fix typo in ipapp
 * :ghpull:`3997`: DOC: typos + rewording in examples/notebooks/Cell Magics.ipynb
 * :ghpull:`3914`: nbconvert: Transformer tests
 * :ghpull:`3987`: get files list in backport_pr
 * :ghpull:`3923`: nbconvert: Writer tests
 * :ghpull:`3974`: nbconvert: Fix app tests on Window7 w/ Python 3.3
 * :ghpull:`3937`: make tab visible in codemirror and light red background
 * :ghpull:`3933`: nbconvert: Post-processor tests
 * :ghpull:`3978`: fix `--existing` with non-localhost IP
 * :ghpull:`3939`: minor checkpoint cleanup
 * :ghpull:`3955`: complete on % for magic in notebook
 * :ghpull:`3981`: BF: fix nbconert rst input prompt spacing
 * :ghpull:`3960`: Don't make sphinx a dependency for importing nbconvert
 * :ghpull:`3973`: logging.Formatter is not new-style in 2.6
 
 Issues (434):
 
 * :ghissue:`5476`: For 2.0: Fix links in Notebook Help Menu
 * :ghissue:`5337`: Examples reorganization
 * :ghissue:`5436`: CodeMirror shortcuts in QuickHelp
 * :ghissue:`5444`: Fix numeric verification for Int and Float text widgets.
 * :ghissue:`5443`: Int and Float Widgets don't allow negative signs
 * :ghissue:`5449`: Stretch keyboard shortcut dialog
 * :ghissue:`5471`: Add coding magic comment to nbconvert Python template
 * :ghissue:`5470`: UTF-8 Issue When Converting Notebook to a Script.
 * :ghissue:`5369`: FormatterWarning for SVG matplotlib output in notebook
 * :ghissue:`5460`: Can't start the notebook server specifying a notebook
 * :ghissue:`2918`: CodeMirror related issues.
 * :ghissue:`5431`: update github_stats and gh_api for 2.0
 * :ghissue:`4887`: Add tests for modal UI
 * :ghissue:`5290`: Add dual mode JS tests
 * :ghissue:`5448`: Cmd+/ shortcut doesn't work in IPython master
 * :ghissue:`5447`: Add %%python2 cell magic
 * :ghissue:`5442`: Make a "python2" alias or rename the "python"cell magic.
 * :ghissue:`2495`: non-ascii characters in the path
 * :ghissue:`4554`: dictDB: Exception due to str to datetime comparission
 * :ghissue:`5006`: Comm code is not run in the same context as notebook code
 * :ghissue:`5118`: Weird interact behavior
 * :ghissue:`5401`: Empty code cells in nbconvert rst output cause problems
 * :ghissue:`5434`: fix check for empty cells in rst template
 * :ghissue:`4944`: Trouble finding ipynb path in Windows 8
 * :ghissue:`4605`: Change the url of Editor Shorcuts in the notebook menu.
 * :ghissue:`5425`: Update COPYING.txt
 * :ghissue:`5348`: BUG: HistoryAccessor.get_session_info(0) - exception
 * :ghissue:`5293`: Javascript("element.append()") looks broken.
 * :ghissue:`5363`: Disable saving if notebook has stopped loading
 * :ghissue:`5189`: Tooltip pager mode is broken
 * :ghissue:`5330`: Updates to shell reference doc
 * :ghissue:`5397`: Accordion widget broken
 * :ghissue:`5106`: Flexbox CSS specificity bugs
 * :ghissue:`5297`: tooltip triggers focus bug
 * :ghissue:`5417`: scp checking for existence of directories: directory names are incorrect
 * :ghissue:`5302`: Parallel engine registration fails for slow engines
 * :ghissue:`5334`: notebook's split-cell shortcut dangerous / incompatible with Neo layout (for instance)
 * :ghissue:`5324`: Style of `raw_input` UI is off in notebook
 * :ghissue:`5350`: Converting notebooks with spaces in their names to RST gives broken images
 * :ghissue:`5049`: update quickhelp on adding and removing shortcuts
 * :ghissue:`4941`: Eliminating display of intermediate stages in progress bars
 * :ghissue:`5345`: nbconvert to markdown does not use backticks
 * :ghissue:`5357`: catch exception in copystat
 * :ghissue:`5351`: Notebook saving fails on smb share
 * :ghissue:`4946`: TeX produced cannot be converted to PDF
 * :ghissue:`5347`: pretty print list too slow
 * :ghissue:`5238`: Raw cell placeholder is not removed when you edit the cell
 * :ghissue:`5382`: Qtconsole doesn't run in Python 3
 * :ghissue:`5378`: Unexpected and new conflict between PyFileConfigLoader and IPythonQtConsoleApp
 * :ghissue:`4945`: Heading/cells positioning problem and cell output wrapping
 * :ghissue:`5084`: Consistent approach for HTML/JS output on nbviewer
 * :ghissue:`4902`: print preview does not work, custom.css not found
 * :ghissue:`5336`: TypeError in bootstrap-tour.min.js
 * :ghissue:`5303`: Changed Hub.registration_timeout to be a config input.
 * :ghissue:`995`: Paste-able mode in terminal
 * :ghissue:`5305`: Tuple unpacking for shell escape
 * :ghissue:`5232`: Make nbconvert html full output like notebook's html.
 * :ghissue:`5224`: Audit nbconvert HTML output
 * :ghissue:`5253`: display any output from this session in terminal console
 * :ghissue:`5251`: ipython console ignoring some stream messages?
 * :ghissue:`4802`: Tour of the notebook UI (was UI elements inline with highlighting)
 * :ghissue:`5103`: Moving Constructor definition to the top like a Function definition
 * :ghissue:`5264`: Test failures on master with Anaconda
 * :ghissue:`4833`: Serve /usr/share/javascript at /_sysassets/javascript/ in notebook
 * :ghissue:`5071`: Prevent %pylab from clobbering interactive
 * :ghissue:`5282`: Exception in widget __del__ methods in Python 3.4.
 * :ghissue:`5280`: append Firefox overflow-x fix
 * :ghissue:`5120`: append Firefox overflow-x fix, again
 * :ghissue:`4127`: autoreload shouldn't rely on .pyc modification times
 * :ghissue:`5272`: allow highlighting language to be set from notebook metadata
 * :ghissue:`5050`: Notebook cells truncated with Firefox
 * :ghissue:`4839`: Error in Session.send_raw()
 * :ghissue:`5188`: New events system
 * :ghissue:`5076`: Refactor keyboard handling
 * :ghissue:`4886`: Refactor and consolidate different keyboard logic in JavaScript code
 * :ghissue:`5002`: the green cell border moving forever in Chrome, when there are many code cells.
 * :ghissue:`5259`: Codemirror still active in command mode
 * :ghissue:`5219`: Output images appear as small thumbnails (Notebook)
 * :ghissue:`4829`: Not able to connect qtconsole in Windows 8
 * :ghissue:`5152`: Hide __pycache__ in dashboard directory list
 * :ghissue:`5151`: Case-insesitive sort for dashboard list
 * :ghissue:`4603`: Warn when overwriting a notebook with upload
 * :ghissue:`4895`: Improvements to %run completions
 * :ghissue:`3459`: Filename completion when run script with %run
 * :ghissue:`5225`: Add JavaScript to nbconvert HTML display priority
 * :ghissue:`5034`: Audit the places where we call `.html(something)`
 * :ghissue:`5094`: Dancing cells in notebook
 * :ghissue:`4999`: Notebook focus effects
 * :ghissue:`5149`: Clicking on a TextBoxWidget in FF completely breaks dual mode.
 * :ghissue:`5207`: Children fire event
 * :ghissue:`5227`: display_method of objects with custom __getattr__
 * :ghissue:`5236`: Cursor keys do not work to leave Markdown cell while it's being edited
 * :ghissue:`5205`: Use CTuple traitlet for Widget children
 * :ghissue:`5230`: notebook rename does not respect url prefix
 * :ghissue:`5218`: Test failures with Python 3 and enabled warnings
 * :ghissue:`5115`: Page Breaks for Print Preview Broken by display: flex - Simple CSS Fix
 * :ghissue:`5024`: Make nbconvert HTML output smart about page breaking
 * :ghissue:`4985`: Add automatic Closebrackets function to Codemirror.
 * :ghissue:`5184`: print '\xa' crashes the interactive shell
 * :ghissue:`5214`: Downloading notebook as Python (.py) fails
 * :ghissue:`5211`: AttributeError: 'module' object has no attribute '_outputfile'
 * :ghissue:`5206`: [CSS?] Inconsistencies in nbconvert divs and IPython Notebook divs?
 * :ghissue:`5201`: node != nodejs within Debian packages
 * :ghissue:`5112`: band-aid for completion
 * :ghissue:`4860`: Completer As-You-Type Broken
 * :ghissue:`5116`: reorganize who knows what about paths
 * :ghissue:`4973`: Adding security.js with 1st attempt at is_safe
 * :ghissue:`5164`: test_oinspect.test_calltip_builtin failure with python3.4
 * :ghissue:`5127`: Widgets: skip intermediate callbacks during throttling
 * :ghissue:`5013`: Widget alignment differs between FF and Chrome
 * :ghissue:`5141`: tornado error static file
 * :ghissue:`5160`: TemporaryWorkingDirectory incompatible with python3.4
 * :ghissue:`5140`: WIP: %kernels magic
 * :ghissue:`4987`: Widget lifecycle problems
 * :ghissue:`5129`: UCS package break latex export on non-ascii 
 * :ghissue:`4986`: Cell horizontal scrollbar is missing in FF but not in Chrome
 * :ghissue:`4685`: nbconvert ignores image size metadata
 * :ghissue:`5155`: Notebook logout button does not work (source typo)
 * :ghissue:`2678`: Ctrl-m keyboard shortcut clash on Chrome OS
 * :ghissue:`5113`: ButtonWidget without caption wrong height.
 * :ghissue:`4778`: add APIs for installing notebook extensions
 * :ghissue:`5046`: python setup.py failed vs git submodule update worked
 * :ghissue:`4925`: Notebook manager api fixes
 * :ghissue:`5073`: Cannot align widgets horizontally in the notebook
 * :ghissue:`4996`: require print_method to be a bound method
 * :ghissue:`4990`: _repr_html_ exception reporting corner case when using type(foo)
 * :ghissue:`5099`: Notebook: Changing base_project_url results in failed WebSockets call
 * :ghissue:`5096`: Client.map is not fault tolerant
 * :ghissue:`4997`: Inconsistent %matplotlib qt behavior
 * :ghissue:`5041`: Remove more .html(...) calls.
 * :ghissue:`5078`: Updating JS tests README.md
 * :ghissue:`4977`: ensure scp destination directories exist (with mkdir -p)
 * :ghissue:`3411`: ipython parallel: scp failure.
 * :ghissue:`5064`: Errors during interact display at the terminal, not anywhere in the notebook
 * :ghissue:`4921`: Add PDF formatter and handling
 * :ghissue:`4920`: Adding PDFFormatter and kernel side handling of PDF display data
 * :ghissue:`5048`: Add edit/command mode indicator
 * :ghissue:`4889`: Add UI element for indicating command/edit modes
 * :ghissue:`5052`: Add q to toggle the pager.
 * :ghissue:`5000`: Closing pager with keyboard in modal UI
 * :ghissue:`5069`: Box model changes broke the Keyboard Shortcuts help modal
 * :ghissue:`4960`: Interact/Interactive for widget
 * :ghissue:`4883`: Implement interact/interactive for widgets
 * :ghissue:`5038`: Fix multiple press keyboard events
 * :ghissue:`5054`: UnicodeDecodeError: 'ascii' codec can't decode byte 0xc6 in position 1: ordinal not in range(128)
 * :ghissue:`5031`: Bug during integration of IPython console in Qt application
 * :ghissue:`5057`: iopubwatcher.py example is broken.
 * :ghissue:`4747`: Add event for output_area adding an output
 * :ghissue:`5001`: Add directory navigation to dashboard
 * :ghissue:`5016`: Help menu external-link icons break layout in FF
 * :ghissue:`4885`: Modal UI behavior changes
 * :ghissue:`5009`: notebook signatures don't work
 * :ghissue:`4975`: setup.py changes for 2.0
 * :ghissue:`4774`: emit event on appended element on dom
 * :ghissue:`5020`: Python Lists translated to javascript objects in widgets
 * :ghissue:`5003`: Fix pretty reprs of super() objects
 * :ghissue:`5012`: Make `SelectionWidget.values` a dict
 * :ghissue:`4961`: Bug when constructing a selection widget with both values and labels
 * :ghissue:`4283`: A `<` in a markdown cell strips cell content when converting to latex
 * :ghissue:`4006`: iptest IPython broken
 * :ghissue:`4251`: & escaped to &amp; in tex ?
 * :ghissue:`5027`: pin lessc to 1.4
 * :ghissue:`4323`: Take 2: citation2latex filter (using HTMLParser)
 * :ghissue:`4196`: Printing notebook from browser gives 1-page truncated output
 * :ghissue:`4842`: more subtle kernel indicator
 * :ghissue:`4057`: No path to notebook examples from Help menu
 * :ghissue:`5015`: don't write cell.trusted to disk
 * :ghissue:`4617`: Changed url link in Help dropdown menu.
 * :ghissue:`4976`: Container widget layout broken on Firefox
 * :ghissue:`4981`: Vertical slider layout broken
 * :ghissue:`4793`: Message spec changes related to `clear_output`
 * :ghissue:`4982`: Live readout for slider widgets
 * :ghissue:`4813`: make help menu a template
 * :ghissue:`4989`: Filename tab completion completely broken
 * :ghissue:`1380`: Tab should insert 4 spaces in # comment lines
 * :ghissue:`2888`: spaces vs tabs
 * :ghissue:`1193`: Allow resizing figures in notebook
 * :ghissue:`4504`: Allow input transformers to raise SyntaxError
 * :ghissue:`4697`: Problems with height after toggling header and toolbar...
 * :ghissue:`4951`: TextWidget to code cell command mode bug.
 * :ghissue:`4809`: Arbitrary scrolling (jumping) in clicks in modal UI for notebook
 * :ghissue:`4971`: Fixing issues with js tests
 * :ghissue:`4972`: Work around problem in doctest discovery in Python 3.4 with PyQt
 * :ghissue:`4892`: IPython.qt test failure with python3.4
 * :ghissue:`4863`: BUG: cannot create an OBJECT array from memory buffer
 * :ghissue:`4704`: Subcommand `profile` ignores --ipython-dir 
 * :ghissue:`4845`: Add Origin Checking.
 * :ghissue:`4870`: ipython_directive, report except/warn in block and add :okexcept: :okwarning: options to suppress
 * :ghissue:`4956`: Shift-Enter does not move to next cell
 * :ghissue:`4662`: Menu cleanup
 * :ghissue:`4824`: sign notebooks
 * :ghissue:`4848`: avoid import of nearby temporary with %edit
 * :ghissue:`4731`: %edit files mistakenly import modules in /tmp
 * :ghissue:`4950`: Two fixes for file upload related bugs
 * :ghissue:`4871`: Notebook upload fails after Delete
 * :ghissue:`4825`: File Upload URL set incorrectly
 * :ghissue:`3867`: display.FileLinks should work in the exported html verion of a notebook
 * :ghissue:`4948`: reveal: ipython css overrides reveal themes
 * :ghissue:`4947`: reveal: slides that are too big?
 * :ghissue:`4051`: Test failures with Python 3 and enabled warnings
 * :ghissue:`3633`: outstanding issues over in ipython/nbconvert repo
 * :ghissue:`4087`: Sympy printing in the example notebook
 * :ghissue:`4627`: Document various QtConsole embedding approaches.
 * :ghissue:`4849`: Various unicode fixes (mostly on Windows)
 * :ghissue:`3653`: autocompletion in "from package import <tab>"
 * :ghissue:`4583`: overwrite? prompt gets EOFError in 2 process
 * :ghissue:`4807`: Correct handling of ansi colour codes when nbconverting to latex
 * :ghissue:`4611`: Document how to compile .less files in dev docs.
 * :ghissue:`4618`: "Editor Shortcuts" link is broken in help menu dropdown notebook
 * :ghissue:`4522`: DeprecationWarning: the sets module is deprecated
 * :ghissue:`4368`: No symlink from ipython to ipython3 when inside a python3 virtualenv
 * :ghissue:`4234`: Math without $$ doesn't show up when converted to slides
 * :ghissue:`4194`: config.TerminalIPythonApp.nosep does not work
 * :ghissue:`1491`: prefilter not called for multi-line notebook cells
 * :ghissue:`4001`: Windows IPython executable /scripts/ipython not working
 * :ghissue:`3959`: think more carefully about text wrapping in nbconvert
 * :ghissue:`4907`: Test for traceback depth fails on Windows
 * :ghissue:`4906`: Test for IPython.embed() fails on Windows
 * :ghissue:`4912`: Skip some Windows io failures
 * :ghissue:`3700`: stdout/stderr should be flushed printing exception output... 
 * :ghissue:`1181`: greedy completer bug in terminal console
 * :ghissue:`2032`: check for a few places we should be using DEFAULT_ENCODING
 * :ghissue:`4882`: Too many files open when starting and stopping kernel repeatedly
 * :ghissue:`4880`: set profile name from profile_dir
 * :ghissue:`4238`: parallel.Client() not using profile that notebook was run with?
 * :ghissue:`4853`: fix setting image height/width from metadata
 * :ghissue:`4786`: Reduce spacing of heading cells
 * :ghissue:`4680`: Minimal pandoc version warning
 * :ghissue:`3707`: nbconvert: Remove IPython magic commands from --format="python" output
 * :ghissue:`4130`: PDF figures as links from png or svg figures
 * :ghissue:`3919`: Allow --profile to be passed a dir.
 * :ghissue:`2136`: Handle hard newlines in pretty printer
 * :ghissue:`4790`: Notebook modal UI: "merge cell below" key binding, `shift+=`, does not work with some keyboard layouts
 * :ghissue:`4884`: Keyboard shortcut changes
 * :ghissue:`1184`: slow handling of keyboard input
 * :ghissue:`4913`: Mathjax, Markdown, tex, env* and italic
 * :ghissue:`3972`: nbconvert: Template output testing
 * :ghissue:`4903`: use https for all embeds
 * :ghissue:`4874`: --debug does not work if you set .kernel_cmd
 * :ghissue:`4679`: JPG compression for inline pylab
 * :ghissue:`4708`: Fix indent and center
 * :ghissue:`4789`: fix IPython.embed
 * :ghissue:`4759`: Application._load_config_files log parameter default fails
 * :ghissue:`3153`: docs / file menu: explain how to exit the notebook
 * :ghissue:`4791`: Did updates to ipython_directive bork support for cython magic snippets?
 * :ghissue:`4385`: "Part 4 - Markdown Cells.ipynb" nbviewer example seems not well referenced in current online documentation page https://ipython.org/ipython-doc/stable/interactive/notebook.htm
 * :ghissue:`4655`: prefer marked to pandoc for markdown2html
 * :ghissue:`3441`: Fix focus related problems in the notebook
 * :ghissue:`3402`: Feature Request: Save As (latex, html,..etc) as a menu option in Notebook rather than explicit need to invoke nbconvert
 * :ghissue:`3224`: Revisit layout of notebook area
 * :ghissue:`2746`: rerunning a cell with long output (exception) scrolls to much (html notebook)
 * :ghissue:`2667`: can't save opened notebook if accidentally delete the notebook in the dashboard
 * :ghissue:`3026`: Reporting errors from _repr_<type>_ methods
 * :ghissue:`1844`: Notebook does not exist and permalinks
 * :ghissue:`2450`: [closed PR] Prevent jumping of window to input when output is clicked.
 * :ghissue:`3166`: IPEP 16: Notebook multi directory dashboard and URL mapping
 * :ghissue:`3691`: Slight misalignment of Notebook menu bar with focus box
 * :ghissue:`4875`: Empty tooltip with `object_found = false` still being shown
 * :ghissue:`4432`: The SSL cert for the MathJax CDN is invalid and URL is not protocol agnostic
 * :ghissue:`2633`: Help text should leave current cell active
 * :ghissue:`3976`: DOC: Pandas link on the notebook help menu?
 * :ghissue:`4082`: /new handler redirect cached by browser
 * :ghissue:`4298`: Slow ipython --pylab and ipython notebook startup
 * :ghissue:`4545`: %store magic not working
 * :ghissue:`4610`: toolbar UI enhancements
 * :ghissue:`4782`: New modal UI
 * :ghissue:`4732`: Accents in notebook names and in command-line (nbconvert)
 * :ghissue:`4752`: link broken in docs/examples
 * :ghissue:`4835`: running ipython on python files adds an extra traceback frame
 * :ghissue:`4792`: repr_html exception warning on qtconsole with pandas  #4745 
 * :ghissue:`4834`: function tooltip issues
 * :ghissue:`4808`: Docstrings in Notebook not displayed properly and introspection
 * :ghissue:`4846`: Remove some leftover traces of irunner
 * :ghissue:`4810`: ipcluster bug in clean_logs flag
 * :ghissue:`4812`: update CodeMirror for the notebook
 * :ghissue:`671`: add migration guide for old IPython config
 * :ghissue:`4783`: ipython 2dev  under windows / (win)python 3.3 experiment
 * :ghissue:`4772`: Notebook server info files
 * :ghissue:`4765`: missing build script for highlight.js
 * :ghissue:`4787`: non-python kernels run python code with qtconsole
 * :ghissue:`4703`: Math macro in jinja templates.
 * :ghissue:`4595`: ipython notebook XSS vulnerable
 * :ghissue:`4776`: Manually document py3compat module.
 * :ghissue:`4686`: For-in loop on an array in cell.js
 * :ghissue:`3605`: Modal UI
 * :ghissue:`4769`: Ipython 2.0 will not startup on py27 on windows
 * :ghissue:`4482`: reveal.js converter not including CDN by default?
 * :ghissue:`4761`: ipv6 address triggers cookie exception
 * :ghissue:`4580`: rename or remove %profile magic
 * :ghissue:`4643`: Docstring does not open properly
 * :ghissue:`4714`: Static URLs are not auto-versioned
 * :ghissue:`2573`: document code mirror keyboard shortcuts
 * :ghissue:`4717`: hang in parallel.Client when using SSHAgent
 * :ghissue:`4544`: Clarify the requirement for pyreadline on Windows
 * :ghissue:`3451`: revisit REST /new handler to avoid systematic crawling.
 * :ghissue:`2922`: File => Save as '.py' saves magic as code 
 * :ghissue:`4728`: Copy/Paste stripping broken in version > 0.13.x in QTConsole
 * :ghissue:`4539`: Nbconvert: Latex to PDF conversion fails on notebooks with accented letters
 * :ghissue:`4721`: purge_results with jobid crashing - looking for insight
 * :ghissue:`4620`: Notebook with ? in title defies autosave, renaming and deletion.
 * :ghissue:`4574`: Hash character in notebook name breaks a lot of things
 * :ghissue:`4709`: input_prefilter hook not called
 * :ghissue:`1680`: qtconsole should support --no-banner and custom banner
 * :ghissue:`4689`: IOStream IP address configurable
 * :ghissue:`4698`: Missing "if __name__ == '__main__':" check in /usr/bin/ipython
 * :ghissue:`4191`: NBConvert: markdown inline and locally referenced files have incorrect file location for latex 
 * :ghissue:`2865`: %%!? does not display the shell execute docstring
 * :ghissue:`1551`: Notebook should be saved before printing
 * :ghissue:`4612`: remove `Configurable.created` ?
 * :ghissue:`4629`: Lots of tests fail due to space in sys.executable
 * :ghissue:`4644`: Fixed URLs for notebooks
 * :ghissue:`4621`: IPython 1.1.0 Qtconsole syntax highlighting highlights python 2 only built-ins when using python 3
 * :ghissue:`2923`: Move Delete Button Away from Save Button in the HTML notebook toolbar
 * :ghissue:`4615`: UnicodeDecodeError
 * :ghissue:`4431`: ipython slow in os x mavericks?
 * :ghissue:`4538`: DOC: document how to change ipcontroller-engine.json in case controller was started with --ip="*"
 * :ghissue:`4551`: Serialize methods and closures
 * :ghissue:`4081`: [Nbconvert][reveal] link to font awesome ?
 * :ghissue:`4602`: "ipcluster stop" fails after "ipcluster start --daemonize" using python3.3
 * :ghissue:`4578`: NBconvert fails with unicode errors when `--stdout` and file redirection is specified and HTML entities are present
 * :ghissue:`4600`: Renaming new notebook to an exist name silently deletes the old one
 * :ghissue:`4598`: Qtconsole docstring pop-up fails on method containing defaulted enum argument
 * :ghissue:`951`: Remove Tornado monkeypatch
 * :ghissue:`4564`: Notebook save failure
 * :ghissue:`4562`: nbconvert: Default encoding problem on OS X
 * :ghissue:`1675`: add file_to_run=file.ipynb capability to the notebook
 * :ghissue:`4516`: `ipython console` doesn't send a `shutdown_request`
 * :ghissue:`3043`: can't restart pdb session in ipython
 * :ghissue:`4524`: Fix bug with non ascii passwords in notebook login
 * :ghissue:`1866`: problems rendering an SVG?
 * :ghissue:`4520`: unicode error when trying Audio('data/Bach Cello Suite #3.wav') 
 * :ghissue:`4493`: Qtconsole cannot print an ISO8601 date at nanosecond precision
 * :ghissue:`4502`: intermittent parallel test failure test_purge_everything 
 * :ghissue:`4495`: firefox 25.0: notebooks report "Notebook save failed", .py script save fails, but .ipynb save succeeds
 * :ghissue:`4245`: nbconvert latex: code highlighting causes error
 * :ghissue:`4486`: Test for whether inside virtualenv does not work if directory is symlinked
 * :ghissue:`4485`: Incorrect info in "Messaging in IPython" documentation. 
 * :ghissue:`4447`: Ipcontroller broken in current HEAD on windows
 * :ghissue:`4241`: Audio display object
 * :ghissue:`4463`: Error on empty c.Session.key
 * :ghissue:`4454`: UnicodeDecodeError when starting Ipython notebook on a directory containing a file with a non-ascii character
 * :ghissue:`3801`: Autocompletion: Fix issue #3723 -- ordering of completions for magic commands and variables with same name
 * :ghissue:`3723`: Code completion: 'matplotlib' and '%matplotlib'
 * :ghissue:`4396`: Always checkpoint al least once ?
 * :ghissue:`2524`: [Notebook] Clear kernel queue
 * :ghissue:`2292`: Client side tests for the notebook
 * :ghissue:`4424`: Dealing with images in multidirectory environment
 * :ghissue:`4388`: Make writing configurable magics easier
 * :ghissue:`852`: Notebook should be saved before downloading
 * :ghissue:`3708`: ipython profile locate should also work
 * :ghissue:`1349`: `?` may generate hundreds of cell 
 * :ghissue:`4381`: Using hasattr for trait_names instead of just looking for it directly/using __dir__?
 * :ghissue:`4361`: Crash Ultratraceback/ session history
 * :ghissue:`3044`: IPython notebook autocomplete for filename string converts multiple spaces to a single space
 * :ghissue:`3346`: Up arrow history search shows duplicates in Qtconsole
 * :ghissue:`3496`: Fix import errors when running tests from the source directory
 * :ghissue:`4114`: If default profile doesn't exist, can't install mathjax to any location
 * :ghissue:`4335`: TestPylabSwitch.test_qt fails
 * :ghissue:`4291`: serve like option for nbconvert --to latex
 * :ghissue:`1824`: Exception before prompting for password during ssh connection
 * :ghissue:`4309`: Error in nbconvert - closing </code> tag is not inserted in HTML under some circumstances
 * :ghissue:`4351`: /parallel/apps/launcher.py error
 * :ghissue:`3603`: Upcoming issues with nbconvert
 * :ghissue:`4296`: sync_imports() fails in python 3.3
 * :ghissue:`4339`: local mathjax install doesn't work
 * :ghissue:`4334`: NotebookApp.webapp_settings static_url_prefix causes crash
 * :ghissue:`4308`: Error when use "ipython notebook" in win7 64 with python2.7.3 64.
 * :ghissue:`4317`: Relative imports broken in the notebook (Windows)
 * :ghissue:`3658`: Saving Notebook clears "Kernel Busy" status from the page and titlebar
 * :ghissue:`4312`: Link broken on ipython-doc stable
 * :ghissue:`1093`: Add boundary options to %load
 * :ghissue:`3619`: Multi-dir webservice design
 * :ghissue:`4299`: Nbconvert, default_preprocessors to list of dotted name not list of obj
 * :ghissue:`3210`: IPython.parallel tests seem to hang on ShiningPanda
 * :ghissue:`4280`: MathJax Automatic Line Breaking
 * :ghissue:`4039`: Celltoolbar example issue
 * :ghissue:`4247`: nbconvert --to latex: error when converting greek letter
 * :ghissue:`4273`: %%capture not capturing rich objects like plots (IPython 1.1.0)
 * :ghissue:`3866`: Vertical offsets in LaTeX output for nbconvert
 * :ghissue:`3631`: xkcd mode for the IPython notebook
 * :ghissue:`4243`: Test exclusions not working on Windows
 * :ghissue:`4256`: IPython no longer handles unicode file names 
 * :ghissue:`3656`: Audio displayobject
 * :ghissue:`4223`: Double output on Ctrl-enter-enter
 * :ghissue:`4184`: nbconvert: use r pygmentize backend when highlighting "%%R" cells 
 * :ghissue:`3851`: Adds an explicit newline for pretty-printing.
 * :ghissue:`3622`: Drop fakemodule
 * :ghissue:`4122`: Nbconvert [windows]: Inconsistent line endings in markdown cells exported to latex 
 * :ghissue:`3819`: nbconvert add extra blank line to code block on Windows.
 * :ghissue:`4203`: remove spurious print statement from parallel annoted functions
 * :ghissue:`4200`: Notebook: merging a heading cell and markdown cell cannot be undone
 * :ghissue:`3747`: ipynb -> ipynb transformer
 * :ghissue:`4024`: nbconvert markdown issues
 * :ghissue:`3903`: on Windows, 'ipython3 nbconvert "C:/blabla/first_try.ipynb" --to slides' gives an unexpected result, and '--post serve' fails
 * :ghissue:`4095`: Catch js error in append html in stream/pyerr
 * :ghissue:`1880`: Add parallelism to test_pr 
 * :ghissue:`4085`: nbconvert: Fix sphinx preprocessor date format string for Windows
 * :ghissue:`4156`: Specifying --gui=tk at the command line
 * :ghissue:`4146`: Having to prepend 'files/' to markdown image paths is confusing 
 * :ghissue:`3818`: nbconvert can't handle Heading with Chinese characters on Japanese Windows OS.
 * :ghissue:`4134`: multi-line parser fails on ''' in comment, qtconsole and notebook.
 * :ghissue:`3998`: sample custom.js needs to be updated
 * :ghissue:`4078`: StoreMagic.autorestore not working in 1.0.0
 * :ghissue:`3990`: Buitlin `input` doesn't work over zmq
 * :ghissue:`4015`: nbconvert fails to convert all the content of a notebook
 * :ghissue:`4059`: Issues with Ellipsis literal in Python 3
 * :ghissue:`2310`: "ZMQError: Interrupted system call" from RichIPythonWidget
 * :ghissue:`3807`: qtconsole ipython 0.13.2 - html/xhtml export fails
 * :ghissue:`4103`: Wrong default argument of DirectView.clear
 * :ghissue:`4100`: parallel.client.client references undefined error.EngineError
 * :ghissue:`484`: Drop nosepatch
 * :ghissue:`3350`: Added longlist support in ipdb.
 * :ghissue:`1591`: Keying 'q' doesn't quit the interactive help in Wins7
 * :ghissue:`40`: The tests in test_process fail under Windows
 * :ghissue:`3744`: capture rich output as well as stdout/err in capture_output
 * :ghissue:`3742`: %%capture to grab rich display outputs
 * :ghissue:`3863`: Added working speaker notes for slides.
 * :ghissue:`4013`: Iptest fails in dual python installation
 * :ghissue:`4005`: IPython.start_kernel doesn't work.
 * :ghissue:`4020`: IPython parallel map fails on numpy arrays
 * :ghissue:`3914`: nbconvert: Transformer tests
 * :ghissue:`3923`: nbconvert: Writer tests
 * :ghissue:`3945`: nbconvert: commandline tests fail Win7x64 Py3.3
 * :ghissue:`3937`: make tab visible in codemirror and light red background
 * :ghissue:`3935`: No feedback for mixed tabs and spaces
 * :ghissue:`3933`: nbconvert: Post-processor tests
 * :ghissue:`3977`: unable to complete remote connections for two-process 
 * :ghissue:`3939`: minor checkpoint cleanup
 * :ghissue:`3955`: complete on % for magic in notebook
 * :ghissue:`3954`: all magics should be listed when completing on %
 * :ghissue:`3980`: nbconvert rst output lacks needed blank lines
 * :ghissue:`3968`: TypeError: super() argument 1 must be type, not classobj (Python 2.6.6)
 * :ghissue:`3880`: nbconvert: R&D remaining tests
 * :ghissue:`2440`: IPEP 4: Python 3 Compatibility

docs/source/whatsnew/version0.9.rst

@@ -1,283 +1,283 b''
 ========================================
 0.9 series
 ========================================
 
 Release 0.9.1
 =============
 
 This release was quickly made to restore compatibility with Python 2.4, which
 version 0.9 accidentally broke.  No new features were introduced, other than
 some additional testing support for internal use.
 
 
 Release 0.9
 ===========
 
 New features
 ------------
 
 * All furl files and security certificates are now put in a read-only
   directory named ~/.ipython/security.
 
 * A single function :func:`get_ipython_dir`, in :mod:`IPython.genutils` that
   determines the user's IPython directory in a robust manner.
 
 * Laurent's WX application has been given a top-level script called
   ipython-wx, and it has received numerous fixes. We expect this code to be
   architecturally better integrated with Gael's WX 'ipython widget' over the
   next few releases.
 
 * The Editor synchronization work by Vivian De Smedt has been merged in.  This
   code adds a number of new editor hooks to synchronize with editors under
   Windows.
 
 * A new, still experimental but highly functional, WX shell by Gael Varoquaux.
   This work was sponsored by Enthought, and while it's still very new, it is
   based on a more cleanly organized architecture of the various IPython
   components. We will continue to develop this over the next few releases as a
   model for GUI components that use IPython.
 
 * Another GUI frontend, Cocoa based (Cocoa is the OSX native GUI framework),
   authored by Barry Wark.  Currently the WX and the Cocoa ones have slightly
   different internal organizations, but the whole team is working on finding
   what the right abstraction points are for a unified codebase.
 
 * As part of the frontend work, Barry Wark also implemented an experimental
   event notification system that various ipython components can use.  In the
   next release the implications and use patterns of this system regarding the
   various GUI options will be worked out.
 
 * IPython finally has a full test system, that can test docstrings with
   IPython-specific functionality.  There are still a few pieces missing for it
   to be widely accessible to all users (so they can run the test suite at any
   time and report problems), but it now works for the developers.  We are
   working hard on continuing to improve it, as this was probably IPython's
   major Achilles heel (the lack of proper test coverage made it effectively
   impossible to do large-scale refactoring).  The full test suite can now
   be run using the :command:`iptest` command line program.
 
 * The notion of a task has been completely reworked.  An `ITask` interface has
   been created.  This interface defines the methods that tasks need to
   implement.  These methods are now responsible for things like submitting
   tasks and processing results.  There are two basic task types:
   :class:`IPython.kernel.task.StringTask` (this is the old `Task` object, but
   renamed) and the new :class:`IPython.kernel.task.MapTask`, which is based on
   a function.
 
 * A new interface, :class:`IPython.kernel.mapper.IMapper` has been defined to
   standardize the idea of a `map` method.  This interface has a single `map`
   method that has the same syntax as the built-in `map`.  We have also defined
   a `mapper` factory interface that creates objects that implement
   :class:`IPython.kernel.mapper.IMapper` for different controllers.  Both the
   multiengine and task controller now have mapping capabilities.
 
 * The parallel function capabilities have been reworks.  The major changes are
   that i) there is now an `@parallel` magic that creates parallel functions,
   ii) the syntax for multiple variable follows that of `map`, iii) both the
   multiengine and task controller now have a parallel function implementation.
 
 * All of the parallel computing capabilities from `ipython1-dev` have been
   merged into IPython proper.  This resulted in the following new subpackages:
   :mod:`IPython.kernel`, :mod:`IPython.kernel.core`, :mod:`traitlets.config`,
   :mod:`IPython.tools` and :mod:`IPython.testing`.
 
-* As part of merging in the `ipython1-dev` stuff, the `setup.py` script and
+* As part of merging in the `ipython1-dev` stuff, the ``setup.py`` script and
   friends have been completely refactored.  Now we are checking for
   dependencies using the approach that matplotlib uses.
 
 * The documentation has been completely reorganized to accept the 
   documentation from `ipython1-dev`.
 
 * We have switched to using Foolscap for all of our network protocols in
   :mod:`IPython.kernel`.  This gives us secure connections that are both
   encrypted and authenticated.
 
 * We have a brand new `COPYING.txt` files that describes the IPython license
   and copyright. The biggest change is that we are putting "The IPython
   Development Team" as the copyright holder. We give more details about
   exactly what this means in this file. All developer should read this and use
   the new banner in all IPython source code files.
 
 * sh profile: ./foo runs foo as system command, no need to do !./foo anymore
 
 * String lists now support ``sort(field, nums = True)`` method (to easily sort
   system command output). Try it with ``a = !ls -l ; a.sort(1, nums=1)``.
 
 * '%cpaste foo' now assigns the pasted block as string list, instead of string
 
 * The ipcluster script now run by default with no security.  This is done
   because the main usage of the script is for starting things on localhost.
   Eventually when ipcluster is able to start things on other hosts, we will put
   security back.
 
 * 'cd --foo' searches directory history for string foo, and jumps to that dir.
   Last part of dir name is checked first. If no matches for that are found,
   look at the whole path.
 
   
 Bug fixes
 ---------
 
 * The Windows installer has been fixed.  Now all IPython scripts have ``.bat``
   versions created.  Also, the Start Menu shortcuts have been updated.
 
 * The colors escapes in the multiengine client are now turned off on win32 as
   they don't print correctly.
 
 * The :mod:`IPython.kernel.scripts.ipengine` script was exec'ing
   mpi_import_statement incorrectly, which was leading the engine to crash when
   mpi was enabled.
 
 * A few subpackages had missing ``__init__.py`` files.
 
 * The documentation is only created if Sphinx is found.  Previously, the
   ``setup.py`` script would fail if it was missing.
 
 * Greedy ``cd`` completion has been disabled again (it was enabled in 0.8.4) as
   it caused problems on certain platforms.
           
 
 Backwards incompatible changes
 ------------------------------
 
 * The ``clusterfile`` options of the :command:`ipcluster` command has been
   removed as it was not working and it will be replaced soon by something much
   more robust.
 
 * The :mod:`IPython.kernel` configuration now properly find the user's
   IPython directory.
 
 * In ipapi, the :func:`make_user_ns` function has been replaced with
   :func:`make_user_namespaces`, to support dict subclasses in namespace
   creation.
 
 * :class:`IPython.kernel.client.Task` has been renamed
   :class:`IPython.kernel.client.StringTask` to make way for new task types.
 
 * The keyword argument `style` has been renamed `dist` in `scatter`, `gather`
   and `map`.
 
 * Renamed the values that the rename `dist` keyword argument can have from
   `'basic'` to `'b'`.
 
 * IPython has a larger set of dependencies if you want all of its capabilities.
-  See the `setup.py` script for details.
+  See the ``setup.py`` script for details.
 
 * The constructors for :class:`IPython.kernel.client.MultiEngineClient` and 
   :class:`IPython.kernel.client.TaskClient` no longer take the (ip,port) tuple.
   Instead they take the filename of a file that contains the FURL for that
   client.  If the FURL file is in your IPYTHONDIR, it will be found automatically
   and the constructor can be left empty.
 
 * The asynchronous clients in :mod:`IPython.kernel.asyncclient` are now created 
   using the factory functions :func:`get_multiengine_client` and 
   :func:`get_task_client`.  These return a `Deferred` to the actual client.
 
 * The command line options to `ipcontroller` and `ipengine` have changed to
   reflect the new Foolscap network protocol and the FURL files.  Please see the
   help for these scripts for details.
 
 * The configuration files for the kernel have changed because of the Foolscap
   stuff.  If you were using custom config files before, you should delete them
   and regenerate new ones.
 
 Changes merged in from IPython1
 -------------------------------
 
 New features
 ............
 
 * Much improved ``setup.py`` and ``setupegg.py`` scripts.  Because Twisted and
   zope.interface are now easy installable, we can declare them as dependencies
   in our setupegg.py script.
 
 * IPython is now compatible with Twisted 2.5.0 and 8.x.
 
 * Added a new example of how to use :mod:`ipython1.kernel.asynclient`.
 
 * Initial draft of a process daemon in :mod:`ipython1.daemon`.  This has not
   been merged into IPython and is still in `ipython1-dev`.
   
 * The ``TaskController`` now has methods for getting the queue status.
 
 * The ``TaskResult`` objects not have information about how long the task
   took to run.
   
 * We are attaching additional attributes to exceptions ``(_ipython_*)`` that 
   we use to carry additional info around.
   
 * New top-level module :mod:`asyncclient` that has asynchronous versions (that
   return deferreds) of the client classes.  This is designed to users who want
   to run their own Twisted reactor.
   
 * All the clients in :mod:`client` are now based on Twisted.  This is done by 
   running the Twisted reactor in a separate thread and using the
   :func:`blockingCallFromThread` function that is in recent versions of Twisted.
 
 * Functions can now be pushed/pulled to/from engines using
   :meth:`MultiEngineClient.push_function` and
   :meth:`MultiEngineClient.pull_function`.
 
 * Gather/scatter are now implemented in the client to reduce the work load
   of the controller and improve performance.
 
 * Complete rewrite of the IPython docuementation.  All of the documentation
   from the IPython website has been moved into docs/source as restructured
   text documents.  PDF and HTML documentation are being generated using 
   Sphinx.
 
 * New developer oriented documentation: development guidelines and roadmap. 
 
 * Traditional ``ChangeLog`` has been changed to a more useful ``changes.txt``
   file that is organized by release and is meant to provide something more
   relevant for users.
 
 Bug fixes
 .........
 
 * Created a proper ``MANIFEST.in`` file to create source distributions.
 
 * Fixed a bug in the ``MultiEngine`` interface.  Previously, multi-engine 
   actions were being collected with a :class:`DeferredList` with 
   ``fireononeerrback=1``.  This meant that methods were returning 
   before all engines had given their results.  This was causing extremely odd 
   bugs in certain cases. To fix this problem, we have 1) set 
   ``fireononeerrback=0`` to make sure all results (or exceptions) are in 
   before returning and 2) introduced a :exc:`CompositeError` exception 
   that wraps all of the engine exceptions.  This is a huge change as it means 
   that users will have to catch :exc:`CompositeError` rather than the actual
   exception.
 
 Backwards incompatible changes
 ..............................
 
 * All names have been renamed to conform to the lowercase_with_underscore
   convention.  This will require users to change references to all names like
   ``queueStatus`` to ``queue_status``.
 
 * Previously, methods like :meth:`MultiEngineClient.push` and
   :meth:`MultiEngineClient.push` used ``*args`` and ``**kwargs``.  This was
   becoming a problem as we weren't able to introduce new keyword arguments into
   the API.  Now these methods simple take a dict or sequence.  This has also
   allowed us to get rid of the ``*All`` methods like :meth:`pushAll` and
   :meth:`pullAll`.  These things are now handled with the ``targets`` keyword
   argument that defaults to ``'all'``.
 
 * The :attr:`MultiEngineClient.magicTargets` has been renamed to
   :attr:`MultiEngineClient.targets`. 
 
 * All methods in the MultiEngine interface now accept the optional keyword
   argument ``block``.
 
 * Renamed :class:`RemoteController` to :class:`MultiEngineClient` and 
   :class:`TaskController` to :class:`TaskClient`.
 
 * Renamed the top-level module from :mod:`api` to :mod:`client`.
 
 * Most methods in the multiengine interface now raise a :exc:`CompositeError`
   exception that wraps the user's exceptions, rather than just raising the raw
   user's exception.
 
 * Changed the ``setupNS`` and ``resultNames`` in the ``Task`` class to ``push`` 
   and ``pull``.